!(function (e) {
  if ("object" == typeof exports && "undefined" != typeof module)
    module.exports = e();
  else if ("function" == typeof define && define.amd) define([], e);
  else {
    var f;
    "undefined" != typeof window
      ? (f = window)
      : "undefined" != typeof global
      ? (f = global)
      : "undefined" != typeof self && (f = self),
      (f.html2canvas = e());
  }
})(function () {
  var define, module, exports;
  return (function e(t, n, r) {
    function s(o, u) {
      if (!n[o]) {
        if (!t[o]) {
          var a = typeof require == "function" && require;
          if (!u && a) return a(o, !0);
          if (i) return i(o, !0);
          var f = new Error("Cannot find module '" + o + "'");
          throw ((f.code = "MODULE_NOT_FOUND"), f);
        }
        var l = (n[o] = { exports: {} });
        t[o][0].call(
          l.exports,
          function (e) {
            var n = t[o][1][e];
            return s(n ? n : e);
          },
          l,
          l.exports,
          e,
          t,
          n,
          r
        );
      }
      return n[o].exports;
    }
    var i = typeof require == "function" && require;
    for (var o = 0; o < r.length; o++) s(r[o]);
    return s;
  })(
    {
      1: [
        function (_dereq_, module, exports) {
          (function (global) {
            /*! http://mths.be/punycode v1.2.4 by @mathias */
            (function (root) {
              /** Detect free variables */
              var freeExports = typeof exports == "object" && exports;
              var freeModule =
                typeof module == "object" &&
                module &&
                module.exports == freeExports &&
                module;
              var freeGlobal = typeof global == "object" && global;
              if (
                freeGlobal.global === freeGlobal ||
                freeGlobal.window === freeGlobal
              ) {
                root = freeGlobal;
              }

              /**
               * The `punycode` object.
               * @name punycode
               * @type Object
               */
              var punycode,
                /** Highest positive signed 32-bit float value */
                maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
                /** Bootstring parameters */
                base = 36,
                tMin = 1,
                tMax = 26,
                skew = 38,
                damp = 700,
                initialBias = 72,
                initialN = 128, // 0x80
                delimiter = "-", // '\x2D'
                /** Regular expressions */
                regexPunycode = /^xn--/,
                regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars
                regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g, // RFC 3490 separators
                /** Error messages */
                errors = {
                  overflow: "Overflow: input needs wider integers to process",
                  "not-basic": "Illegal input >= 0x80 (not a basic code point)",
                  "invalid-input": "Invalid input",
                },
                /** Convenience shortcuts */
                baseMinusTMin = base - tMin,
                floor = Math.floor,
                stringFromCharCode = String.fromCharCode,
                /** Temporary variable */
                key;

              /*--------------------------------------------------------------------------*/

              /**
               * A generic error utility function.
               * @private
               * @param {String} type The error type.
               * @returns {Error} Throws a `RangeError` with the applicable error message.
               */
              function error(type) {
                throw RangeError(errors[type]);
              }

              /**
               * A generic `Array#map` utility function.
               * @private
               * @param {Array} array The array to iterate over.
               * @param {Function} callback The function that gets called for every array
               * item.
               * @returns {Array} A new array of values returned by the callback function.
               */
              function map(array, fn) {
                var length = array.length;
                while (length--) {
                  array[length] = fn(array[length]);
                }
                return array;
              }

              /**
               * A simple `Array#map`-like wrapper to work with domain name strings.
               * @private
               * @param {String} domain The domain name.
               * @param {Function} callback The function that gets called for every
               * character.
               * @returns {Array} A new string of characters returned by the callback
               * function.
               */
              function mapDomain(string, fn) {
                return map(string.split(regexSeparators), fn).join(".");
              }

              /**
               * Creates an array containing the numeric code points of each Unicode
               * character in the string. While JavaScript uses UCS-2 internally,
               * this function will convert a pair of surrogate halves (each of which
               * UCS-2 exposes as separate characters) into a single code point,
               * matching UTF-16.
               * @see `punycode.ucs2.encode`
               * @see <http://mathiasbynens.be/notes/javascript-encoding>
               * @memberOf punycode.ucs2
               * @name decode
               * @param {String} string The Unicode input string (UCS-2).
               * @returns {Array} The new array of code points.
               */
              function ucs2decode(string) {
                var output = [],
                  counter = 0,
                  length = string.length,
                  value,
                  extra;
                while (counter < length) {
                  value = string.charCodeAt(counter++);
                  if (value >= 0xd800 && value <= 0xdbff && counter < length) {
                    // high surrogate, and there is a next character
                    extra = string.charCodeAt(counter++);
                    if ((extra & 0xfc00) == 0xdc00) {
                      // low surrogate
                      output.push(
                        ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000
                      );
                    } else {
                      // unmatched surrogate; only append this code unit, in case the next
                      // code unit is the high surrogate of a surrogate pair
                      output.push(value);
                      counter--;
                    }
                  } else {
                    output.push(value);
                  }
                }
                return output;
              }

              /**
               * Creates a string based on an array of numeric code points.
               * @see `punycode.ucs2.decode`
               * @memberOf punycode.ucs2
               * @name encode
               * @param {Array} codePoints The array of numeric code points.
               * @returns {String} The new Unicode string (UCS-2).
               */
              function ucs2encode(array) {
                return map(array, function (value) {
                  var output = "";
                  if (value > 0xffff) {
                    value -= 0x10000;
                    output += stringFromCharCode(
                      ((value >>> 10) & 0x3ff) | 0xd800
                    );
                    value = 0xdc00 | (value & 0x3ff);
                  }
                  output += stringFromCharCode(value);
                  return output;
                }).join("");
              }

              /**
               * Converts a basic code point into a digit/integer.
               * @see `digitToBasic()`
               * @private
               * @param {Number} codePoint The basic numeric code point value.
               * @returns {Number} The numeric value of a basic code point (for use in
               * representing integers) in the range `0` to `base - 1`, or `base` if
               * the code point does not represent a value.
               */
              function basicToDigit(codePoint) {
                if (codePoint - 48 < 10) {
                  return codePoint - 22;
                }
                if (codePoint - 65 < 26) {
                  return codePoint - 65;
                }
                if (codePoint - 97 < 26) {
                  return codePoint - 97;
                }
                return base;
              }

              /**
               * Converts a digit/integer into a basic code point.
               * @see `basicToDigit()`
               * @private
               * @param {Number} digit The numeric value of a basic code point.
               * @returns {Number} The basic code point whose value (when used for
               * representing integers) is `digit`, which needs to be in the range
               * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
               * used; else, the lowercase form is used. The behavior is undefined
               * if `flag` is non-zero and `digit` has no uppercase form.
               */
              function digitToBasic(digit, flag) {
                //  0..25 map to ASCII a..z or A..Z
                // 26..35 map to ASCII 0..9
                return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
              }

              /**
               * Bias adaptation function as per section 3.4 of RFC 3492.
               * http://tools.ietf.org/html/rfc3492#section-3.4
               * @private
               */
              function adapt(delta, numPoints, firstTime) {
                var k = 0;
                delta = firstTime ? floor(delta / damp) : delta >> 1;
                delta += floor(delta / numPoints);
                for (
                  ;
                  /* no initialization */ delta > (baseMinusTMin * tMax) >> 1;
                  k += base
                ) {
                  delta = floor(delta / baseMinusTMin);
                }
                return floor(
                  k + ((baseMinusTMin + 1) * delta) / (delta + skew)
                );
              }

              /**
               * Converts a Punycode string of ASCII-only symbols to a string of Unicode
               * symbols.
               * @memberOf punycode
               * @param {String} input The Punycode string of ASCII-only symbols.
               * @returns {String} The resulting string of Unicode symbols.
               */
              function decode(input) {
                // Don't use UCS-2
                var output = [],
                  inputLength = input.length,
                  out,
                  i = 0,
                  n = initialN,
                  bias = initialBias,
                  basic,
                  j,
                  index,
                  oldi,
                  w,
                  k,
                  digit,
                  t,
                  /** Cached calculation results */
                  baseMinusT;

                // Handle the basic code points: let `basic` be the number of input code
                // points before the last delimiter, or `0` if there is none, then copy
                // the first basic code points to the output.

                basic = input.lastIndexOf(delimiter);
                if (basic < 0) {
                  basic = 0;
                }

                for (j = 0; j < basic; ++j) {
                  // if it's not a basic code point
                  if (input.charCodeAt(j) >= 0x80) {
                    error("not-basic");
                  }
                  output.push(input.charCodeAt(j));
                }

                // Main decoding loop: start just after the last delimiter if any basic code
                // points were copied; start at the beginning otherwise.

                for (
                  index = basic > 0 ? basic + 1 : 0;
                  index < inputLength /* no final expression */;

                ) {
                  // `index` is the index of the next character to be consumed.
                  // Decode a generalized variable-length integer into `delta`,
                  // which gets added to `i`. The overflow checking is easier
                  // if we increase `i` as we go, then subtract off its starting
                  // value at the end to obtain `delta`.
                  for (
                    oldi = i, w = 1, k = base /* no condition */;
                    ;
                    k += base
                  ) {
                    if (index >= inputLength) {
                      error("invalid-input");
                    }

                    digit = basicToDigit(input.charCodeAt(index++));

                    if (digit >= base || digit > floor((maxInt - i) / w)) {
                      error("overflow");
                    }

                    i += digit * w;
                    t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;

                    if (digit < t) {
                      break;
                    }

                    baseMinusT = base - t;
                    if (w > floor(maxInt / baseMinusT)) {
                      error("overflow");
                    }

                    w *= baseMinusT;
                  }

                  out = output.length + 1;
                  bias = adapt(i - oldi, out, oldi == 0);

                  // `i` was supposed to wrap around from `out` to `0`,
                  // incrementing `n` each time, so we'll fix that now:
                  if (floor(i / out) > maxInt - n) {
                    error("overflow");
                  }

                  n += floor(i / out);
                  i %= out;

                  // Insert `n` at position `i` of the output
                  output.splice(i++, 0, n);
                }

                return ucs2encode(output);
              }

              /**
               * Converts a string of Unicode symbols to a Punycode string of ASCII-only
               * symbols.
               * @memberOf punycode
               * @param {String} input The string of Unicode symbols.
               * @returns {String} The resulting Punycode string of ASCII-only symbols.
               */
              function encode(input) {
                var n,
                  delta,
                  handledCPCount,
                  basicLength,
                  bias,
                  j,
                  m,
                  q,
                  k,
                  t,
                  currentValue,
                  output = [],
                  /** `inputLength` will hold the number of code points in `input`. */
                  inputLength,
                  /** Cached calculation results */
                  handledCPCountPlusOne,
                  baseMinusT,
                  qMinusT;

                // Convert the input in UCS-2 to Unicode
                input = ucs2decode(input);

                // Cache the length
                inputLength = input.length;

                // Initialize the state
                n = initialN;
                delta = 0;
                bias = initialBias;

                // Handle the basic code points
                for (j = 0; j < inputLength; ++j) {
                  currentValue = input[j];
                  if (currentValue < 0x80) {
                    output.push(stringFromCharCode(currentValue));
                  }
                }

                handledCPCount = basicLength = output.length;

                // `handledCPCount` is the number of code points that have been handled;
                // `basicLength` is the number of basic code points.

                // Finish the basic string - if it is not empty - with a delimiter
                if (basicLength) {
                  output.push(delimiter);
                }

                // Main encoding loop:
                while (handledCPCount < inputLength) {
                  // All non-basic code points < n have been handled already. Find the next
                  // larger one:
                  for (m = maxInt, j = 0; j < inputLength; ++j) {
                    currentValue = input[j];
                    if (currentValue >= n && currentValue < m) {
                      m = currentValue;
                    }
                  }

                  // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
                  // but guard against overflow
                  handledCPCountPlusOne = handledCPCount + 1;
                  if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
                    error("overflow");
                  }

                  delta += (m - n) * handledCPCountPlusOne;
                  n = m;

                  for (j = 0; j < inputLength; ++j) {
                    currentValue = input[j];

                    if (currentValue < n && ++delta > maxInt) {
                      error("overflow");
                    }

                    if (currentValue == n) {
                      // Represent delta as a generalized variable-length integer
                      for (
                        q = delta, k = base /* no condition */;
                        ;
                        k += base
                      ) {
                        t =
                          k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
                        if (q < t) {
                          break;
                        }
                        qMinusT = q - t;
                        baseMinusT = base - t;
                        output.push(
                          stringFromCharCode(
                            digitToBasic(t + (qMinusT % baseMinusT), 0)
                          )
                        );
                        q = floor(qMinusT / baseMinusT);
                      }

                      output.push(stringFromCharCode(digitToBasic(q, 0)));
                      bias = adapt(
                        delta,
                        handledCPCountPlusOne,
                        handledCPCount == basicLength
                      );
                      delta = 0;
                      ++handledCPCount;
                    }
                  }

                  ++delta;
                  ++n;
                }
                return output.join("");
              }

              /**
               * Converts a Punycode string representing a domain name to Unicode. Only the
               * Punycoded parts of the domain name will be converted, i.e. it doesn't
               * matter if you call it on a string that has already been converted to
               * Unicode.
               * @memberOf punycode
               * @param {String} domain The Punycode domain name to convert to Unicode.
               * @returns {String} The Unicode representation of the given Punycode
               * string.
               */
              function toUnicode(domain) {
                return mapDomain(domain, function (string) {
                  return regexPunycode.test(string)
                    ? decode(string.slice(4).toLowerCase())
                    : string;
                });
              }

              /**
               * Converts a Unicode string representing a domain name to Punycode. Only the
               * non-ASCII parts of the domain name will be converted, i.e. it doesn't
               * matter if you call it with a domain that's already in ASCII.
               * @memberOf punycode
               * @param {String} domain The domain name to convert, as a Unicode string.
               * @returns {String} The Punycode representation of the given domain name.
               */
              function toASCII(domain) {
                return mapDomain(domain, function (string) {
                  return regexNonASCII.test(string)
                    ? "xn--" + encode(string)
                    : string;
                });
              }

              /*--------------------------------------------------------------------------*/

              /** Define the public API */
              punycode = {
                /**
                 * A string representing the current Punycode.js version number.
                 * @memberOf punycode
                 * @type String
                 */
                version: "1.2.4",
                /**
                 * An object of methods to convert from JavaScript's internal character
                 * representation (UCS-2) to Unicode code points, and back.
                 * @see <http://mathiasbynens.be/notes/javascript-encoding>
                 * @memberOf punycode
                 * @type Object
                 */
                ucs2: {
                  decode: ucs2decode,
                  encode: ucs2encode,
                },
                decode: decode,
                encode: encode,
                toASCII: toASCII,
                toUnicode: toUnicode,
              };

              /** Expose `punycode` */
              // Some AMD build optimizers, like r.js, check for specific condition patterns
              // like the following:
              if (
                typeof define == "function" &&
                typeof define.amd == "object" &&
                define.amd
              ) {
                define("punycode", function () {
                  return punycode;
                });
              } else if (freeExports && !freeExports.nodeType) {
                if (freeModule) {
                  // in Node.js or RingoJS v0.8.0+
                  freeModule.exports = punycode;
                } else {
                  // in Narwhal or RingoJS v0.7.0-
                  for (key in punycode) {
                    punycode.hasOwnProperty(key) &&
                      (freeExports[key] = punycode[key]);
                  }
                }
              } else {
                // in Rhino or a web browser
                root.punycode = punycode;
              }
            })(this);
          }.call(
            this,
            typeof global !== "undefined"
              ? global
              : typeof self !== "undefined"
              ? self
              : typeof window !== "undefined"
              ? window
              : {}
          ));
        },
        {},
      ],
      2: [
        function (_dereq_, module, exports) {
          var log = _dereq_("./log");

          function restoreOwnerScroll(ownerDocument, x, y) {
            if (
              ownerDocument.defaultView &&
              (x !== ownerDocument.defaultView.pageXOffset ||
                y !== ownerDocument.defaultView.pageYOffset)
            ) {
              ownerDocument.defaultView.scrollTo(x, y);
            }
          }

          function cloneCanvasContents(canvas, clonedCanvas) {
            try {
              if (clonedCanvas) {
                clonedCanvas.width = canvas.width;
                clonedCanvas.height = canvas.height;
                clonedCanvas
                  .getContext("2d")
                  .putImageData(
                    canvas
                      .getContext("2d")
                      .getImageData(0, 0, canvas.width, canvas.height),
                    0,
                    0
                  );
              }
            } catch (e) {
              log("Unable to copy canvas content from", canvas, e);
            }
          }

          function cloneNode(node, javascriptEnabled) {
            var clone =
              node.nodeType === 3
                ? document.createTextNode(node.nodeValue)
                : node.cloneNode(false);

            var child = node.firstChild;
            while (child) {
              if (
                javascriptEnabled === true ||
                child.nodeType !== 1 ||
                child.nodeName !== "SCRIPT"
              ) {
                clone.appendChild(cloneNode(child, javascriptEnabled));
              }
              child = child.nextSibling;
            }

            if (node.nodeType === 1) {
              clone._scrollTop = node.scrollTop;
              clone._scrollLeft = node.scrollLeft;
              if (node.nodeName === "CANVAS") {
                cloneCanvasContents(node, clone);
              } else if (
                node.nodeName === "TEXTAREA" ||
                node.nodeName === "SELECT"
              ) {
                clone.value = node.value;
              }
            }

            return clone;
          }

          function initNode(node) {
            if (node.nodeType === 1) {
              node.scrollTop = node._scrollTop;
              node.scrollLeft = node._scrollLeft;

              var child = node.firstChild;
              while (child) {
                initNode(child);
                child = child.nextSibling;
              }
            }
          }

          module.exports = function (
            ownerDocument,
            containerDocument,
            width,
            height,
            options,
            x,
            y
          ) {
            var documentElement = cloneNode(
              ownerDocument.documentElement,
              options.javascriptEnabled
            );
            var container = containerDocument.createElement("iframe");

            container.className = "html2canvas-container";
            container.style.visibility = "hidden";
            container.style.position = "fixed";
            container.style.left = "-10000px";
            container.style.top = "0px";
            container.style.border = "0";
            container.width = width;
            container.height = height;
            container.scrolling = "no"; // ios won't scroll without it
            containerDocument.body.appendChild(container);

            return new Promise(function (resolve) {
              var documentClone = container.contentWindow.document;

              /* Chrome doesn't detect relative background-images assigned in inline <style> sheets when fetched through getComputedStyle
         if window url is about:blank, we can assign the url to current by writing onto the document
         */
              container.contentWindow.onload = container.onload = function () {
                var interval = setInterval(function () {
                  if (documentClone.body.childNodes.length > 0) {
                    initNode(documentClone.documentElement);
                    clearInterval(interval);
                    if (options.type === "view") {
                      container.contentWindow.scrollTo(x, y);
                      if (
                        /(iPad|iPhone|iPod)/g.test(navigator.userAgent) &&
                        (container.contentWindow.scrollY !== y ||
                          container.contentWindow.scrollX !== x)
                      ) {
                        documentClone.documentElement.style.top = -y + "px";
                        documentClone.documentElement.style.left = -x + "px";
                        documentClone.documentElement.style.position =
                          "absolute";
                      }
                    }
                    resolve(container);
                  }
                }, 50);
              };

              documentClone.open();
              documentClone.write("<!DOCTYPE html><html></html>");
              // Chrome scrolls the parent document for some reason after the write to the cloned window???
              restoreOwnerScroll(ownerDocument, x, y);
              documentClone.replaceChild(
                documentClone.adoptNode(documentElement),
                documentClone.documentElement
              );
              documentClone.close();
            });
          };
        },
        { "./log": 13 },
      ],
      3: [
        function (_dereq_, module, exports) {
          // http://dev.w3.org/csswg/css-color/

          function Color(value) {
            this.r = 0;
            this.g = 0;
            this.b = 0;
            this.a = null;
            var result =
              this.fromArray(value) ||
              this.namedColor(value) ||
              this.rgb(value) ||
              this.rgba(value) ||
              this.hex6(value) ||
              this.hex3(value);
          }

          Color.prototype.darken = function (amount) {
            var a = 1 - amount;
            return new Color([
              Math.round(this.r * a),
              Math.round(this.g * a),
              Math.round(this.b * a),
              this.a,
            ]);
          };

          Color.prototype.isTransparent = function () {
            return this.a === 0;
          };

          Color.prototype.isBlack = function () {
            return this.r === 0 && this.g === 0 && this.b === 0;
          };

          Color.prototype.fromArray = function (array) {
            if (Array.isArray(array)) {
              this.r = Math.min(array[0], 255);
              this.g = Math.min(array[1], 255);
              this.b = Math.min(array[2], 255);
              if (array.length > 3) {
                this.a = array[3];
              }
            }

            return Array.isArray(array);
          };

          var _hex3 = /^#([a-f0-9]{3})$/i;

          Color.prototype.hex3 = function (value) {
            var match = null;
            if ((match = value.match(_hex3)) !== null) {
              this.r = parseInt(match[1][0] + match[1][0], 16);
              this.g = parseInt(match[1][1] + match[1][1], 16);
              this.b = parseInt(match[1][2] + match[1][2], 16);
            }
            return match !== null;
          };

          var _hex6 = /^#([a-f0-9]{6})$/i;

          Color.prototype.hex6 = function (value) {
            var match = null;
            if ((match = value.match(_hex6)) !== null) {
              this.r = parseInt(match[1].substring(0, 2), 16);
              this.g = parseInt(match[1].substring(2, 4), 16);
              this.b = parseInt(match[1].substring(4, 6), 16);
            }
            return match !== null;
          };

          var _rgb = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;

          Color.prototype.rgb = function (value) {
            var match = null;
            if ((match = value.match(_rgb)) !== null) {
              this.r = Number(match[1]);
              this.g = Number(match[2]);
              this.b = Number(match[3]);
            }
            return match !== null;
          };

          var _rgba = /^rgba\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d?\.?\d+)\s*\)$/;

          Color.prototype.rgba = function (value) {
            var match = null;
            if ((match = value.match(_rgba)) !== null) {
              this.r = Number(match[1]);
              this.g = Number(match[2]);
              this.b = Number(match[3]);
              this.a = Number(match[4]);
            }
            return match !== null;
          };

          Color.prototype.toString = function () {
            return this.a !== null && this.a !== 1
              ? "rgba(" + [this.r, this.g, this.b, this.a].join(",") + ")"
              : "rgb(" + [this.r, this.g, this.b].join(",") + ")";
          };

          Color.prototype.namedColor = function (value) {
            value = value.toLowerCase();
            var color = colors[value];
            if (color) {
              this.r = color[0];
              this.g = color[1];
              this.b = color[2];
            } else if (value === "transparent") {
              this.r = this.g = this.b = this.a = 0;
              return true;
            }

            return !!color;
          };

          Color.prototype.isColor = true;

          // JSON.stringify([].slice.call($$('.named-color-table tr'), 1).map(function(row) { return [row.childNodes[3].textContent, row.childNodes[5].textContent.trim().split(",").map(Number)] }).reduce(function(data, row) {data[row[0]] = row[1]; return data}, {}))
          var colors = {
            aliceblue: [240, 248, 255],
            antiquewhite: [250, 235, 215],
            aqua: [0, 255, 255],
            aquamarine: [127, 255, 212],
            azure: [240, 255, 255],
            beige: [245, 245, 220],
            bisque: [255, 228, 196],
            black: [0, 0, 0],
            blanchedalmond: [255, 235, 205],
            blue: [0, 0, 255],
            blueviolet: [138, 43, 226],
            brown: [165, 42, 42],
            burlywood: [222, 184, 135],
            cadetblue: [95, 158, 160],
            chartreuse: [127, 255, 0],
            chocolate: [210, 105, 30],
            coral: [255, 127, 80],
            cornflowerblue: [100, 149, 237],
            cornsilk: [255, 248, 220],
            crimson: [220, 20, 60],
            cyan: [0, 255, 255],
            darkblue: [0, 0, 139],
            darkcyan: [0, 139, 139],
            darkgoldenrod: [184, 134, 11],
            darkgray: [169, 169, 169],
            darkgreen: [0, 100, 0],
            darkgrey: [169, 169, 169],
            darkkhaki: [189, 183, 107],
            darkmagenta: [139, 0, 139],
            darkolivegreen: [85, 107, 47],
            darkorange: [255, 140, 0],
            darkorchid: [153, 50, 204],
            darkred: [139, 0, 0],
            darksalmon: [233, 150, 122],
            darkseagreen: [143, 188, 143],
            darkslateblue: [72, 61, 139],
            darkslategray: [47, 79, 79],
            darkslategrey: [47, 79, 79],
            darkturquoise: [0, 206, 209],
            darkviolet: [148, 0, 211],
            deeppink: [255, 20, 147],
            deepskyblue: [0, 191, 255],
            dimgray: [105, 105, 105],
            dimgrey: [105, 105, 105],
            dodgerblue: [30, 144, 255],
            firebrick: [178, 34, 34],
            floralwhite: [255, 250, 240],
            forestgreen: [34, 139, 34],
            fuchsia: [255, 0, 255],
            gainsboro: [220, 220, 220],
            ghostwhite: [248, 248, 255],
            gold: [255, 215, 0],
            goldenrod: [218, 165, 32],
            gray: [128, 128, 128],
            green: [0, 128, 0],
            greenyellow: [173, 255, 47],
            grey: [128, 128, 128],
            honeydew: [240, 255, 240],
            hotpink: [255, 105, 180],
            indianred: [205, 92, 92],
            indigo: [75, 0, 130],
            ivory: [255, 255, 240],
            khaki: [240, 230, 140],
            lavender: [230, 230, 250],
            lavenderblush: [255, 240, 245],
            lawngreen: [124, 252, 0],
            lemonchiffon: [255, 250, 205],
            lightblue: [173, 216, 230],
            lightcoral: [240, 128, 128],
            lightcyan: [224, 255, 255],
            lightgoldenrodyellow: [250, 250, 210],
            lightgray: [211, 211, 211],
            lightgreen: [144, 238, 144],
            lightgrey: [211, 211, 211],
            lightpink: [255, 182, 193],
            lightsalmon: [255, 160, 122],
            lightseagreen: [32, 178, 170],
            lightskyblue: [135, 206, 250],
            lightslategray: [119, 136, 153],
            lightslategrey: [119, 136, 153],
            lightsteelblue: [176, 196, 222],
            lightyellow: [255, 255, 224],
            lime: [0, 255, 0],
            limegreen: [50, 205, 50],
            linen: [250, 240, 230],
            magenta: [255, 0, 255],
            maroon: [128, 0, 0],
            mediumaquamarine: [102, 205, 170],
            mediumblue: [0, 0, 205],
            mediumorchid: [186, 85, 211],
            mediumpurple: [147, 112, 219],
            mediumseagreen: [60, 179, 113],
            mediumslateblue: [123, 104, 238],
            mediumspringgreen: [0, 250, 154],
            mediumturquoise: [72, 209, 204],
            mediumvioletred: [199, 21, 133],
            midnightblue: [25, 25, 112],
            mintcream: [245, 255, 250],
            mistyrose: [255, 228, 225],
            moccasin: [255, 228, 181],
            navajowhite: [255, 222, 173],
            navy: [0, 0, 128],
            oldlace: [253, 245, 230],
            olive: [128, 128, 0],
            olivedrab: [107, 142, 35],
            orange: [255, 165, 0],
            orangered: [255, 69, 0],
            orchid: [218, 112, 214],
            palegoldenrod: [238, 232, 170],
            palegreen: [152, 251, 152],
            paleturquoise: [175, 238, 238],
            palevioletred: [219, 112, 147],
            papayawhip: [255, 239, 213],
            peachpuff: [255, 218, 185],
            peru: [205, 133, 63],
            pink: [255, 192, 203],
            plum: [221, 160, 221],
            powderblue: [176, 224, 230],
            purple: [128, 0, 128],
            rebeccapurple: [102, 51, 153],
            red: [255, 0, 0],
            rosybrown: [188, 143, 143],
            royalblue: [65, 105, 225],
            saddlebrown: [139, 69, 19],
            salmon: [250, 128, 114],
            sandybrown: [244, 164, 96],
            seagreen: [46, 139, 87],
            seashell: [255, 245, 238],
            sienna: [160, 82, 45],
            silver: [192, 192, 192],
            skyblue: [135, 206, 235],
            slateblue: [106, 90, 205],
            slategray: [112, 128, 144],
            slategrey: [112, 128, 144],
            snow: [255, 250, 250],
            springgreen: [0, 255, 127],
            steelblue: [70, 130, 180],
            tan: [210, 180, 140],
            teal: [0, 128, 128],
            thistle: [216, 191, 216],
            tomato: [255, 99, 71],
            turquoise: [64, 224, 208],
            violet: [238, 130, 238],
            wheat: [245, 222, 179],
            white: [255, 255, 255],
            whitesmoke: [245, 245, 245],
            yellow: [255, 255, 0],
            yellowgreen: [154, 205, 50],
          };

          module.exports = Color;
        },
        {},
      ],
      4: [
        function (_dereq_, module, exports) {
          var Support = _dereq_("./support");
          var CanvasRenderer = _dereq_("./renderers/canvas");
          var ImageLoader = _dereq_("./imageloader");
          var NodeParser = _dereq_("./nodeparser");
          var NodeContainer = _dereq_("./nodecontainer");
          var log = _dereq_("./log");
          var utils = _dereq_("./utils");
          var createWindowClone = _dereq_("./clone");
          var loadUrlDocument = _dereq_("./proxy").loadUrlDocument;
          var getBounds = utils.getBounds;

          var html2canvasNodeAttribute = "data-html2canvas-node";
          var html2canvasCloneIndex = 0;

          function html2canvas(nodeList, options) {
            var index = html2canvasCloneIndex++;
            options = options || {};
            if (options.logging) {
              log.options.logging = true;
              log.options.start = Date.now();
            }

            options.async =
              typeof options.async === "undefined" ? true : options.async;
            options.allowTaint =
              typeof options.allowTaint === "undefined"
                ? false
                : options.allowTaint;
            options.removeContainer =
              typeof options.removeContainer === "undefined"
                ? true
                : options.removeContainer;
            options.javascriptEnabled =
              typeof options.javascriptEnabled === "undefined"
                ? false
                : options.javascriptEnabled;
            options.imageTimeout =
              typeof options.imageTimeout === "undefined"
                ? 10000
                : options.imageTimeout;
            options.renderer =
              typeof options.renderer === "function"
                ? options.renderer
                : CanvasRenderer;
            options.strict = !!options.strict;

            if (typeof nodeList === "string") {
              if (typeof options.proxy !== "string") {
                return Promise.reject("Proxy must be used when rendering url");
              }
              var width =
                options.width != null ? options.width : window.innerWidth;
              var height =
                options.height != null ? options.height : window.innerHeight;
              return loadUrlDocument(
                absoluteUrl(nodeList),
                options.proxy,
                document,
                width,
                height,
                options
              ).then(function (container) {
                return renderWindow(
                  container.contentWindow.document.documentElement,
                  container,
                  options,
                  width,
                  height
                );
              });
            }

            var node = (nodeList === undefined
              ? [document.documentElement]
              : nodeList.length
              ? nodeList
              : [nodeList])[0];
            node.setAttribute(html2canvasNodeAttribute + index, index);
            return renderDocument(
              node.ownerDocument,
              options,
              node.ownerDocument.defaultView.innerWidth,
              node.ownerDocument.defaultView.innerHeight,
              index
            ).then(function (canvas) {
              if (typeof options.onrendered === "function") {
                log(
                  "options.onrendered is deprecated, html2canvas returns a Promise containing the canvas"
                );
                options.onrendered(canvas);
              }
              return canvas;
            });
          }

          html2canvas.CanvasRenderer = CanvasRenderer;
          html2canvas.NodeContainer = NodeContainer;
          html2canvas.log = log;
          html2canvas.utils = utils;

          var html2canvasExport =
            typeof document === "undefined" ||
            typeof Object.create !== "function" ||
            typeof document.createElement("canvas").getContext !== "function"
              ? function () {
                  return Promise.reject("No canvas support");
                }
              : html2canvas;

          module.exports = html2canvasExport;

          if (typeof define === "function" && define.amd) {
            define("html2canvas", [], function () {
              return html2canvasExport;
            });
          }

          function renderDocument(
            document,
            options,
            windowWidth,
            windowHeight,
            html2canvasIndex
          ) {
            return createWindowClone(
              document,
              document,
              windowWidth,
              windowHeight,
              options,
              document.defaultView.pageXOffset,
              document.defaultView.pageYOffset
            ).then(function (container) {
              log("Document cloned");
              var attributeName = html2canvasNodeAttribute + html2canvasIndex;
              var selector =
                "[" + attributeName + "='" + html2canvasIndex + "']";
              document.querySelector(selector).removeAttribute(attributeName);
              var clonedWindow = container.contentWindow;
              var node = clonedWindow.document.querySelector(selector);
              var oncloneHandler =
                typeof options.onclone === "function"
                  ? Promise.resolve(options.onclone(clonedWindow.document))
                  : Promise.resolve(true);
              return oncloneHandler.then(function () {
                return renderWindow(
                  node,
                  container,
                  options,
                  windowWidth,
                  windowHeight
                );
              });
            });
          }

          function renderWindow(
            node,
            container,
            options,
            windowWidth,
            windowHeight
          ) {
            var clonedWindow = container.contentWindow;
            var support = new Support(clonedWindow.document);
            var imageLoader = new ImageLoader(options, support);
            var bounds = getBounds(node);
            var width =
              options.type === "view"
                ? windowWidth
                : documentWidth(clonedWindow.document);
            var height =
              options.type === "view"
                ? windowHeight
                : documentHeight(clonedWindow.document);
            var renderer = new options.renderer(
              width,
              height,
              imageLoader,
              options,
              document
            );
            var parser = new NodeParser(
              node,
              renderer,
              support,
              imageLoader,
              options
            );
            return parser.ready.then(function () {
              log("Finished rendering");
              var canvas;

              if (options.type === "view") {
                canvas = crop(renderer.canvas, {
                  width: renderer.canvas.width,
                  height: renderer.canvas.height,
                  top: 0,
                  left: 0,
                  x: 0,
                  y: 0,
                });
              } else if (
                node === clonedWindow.document.body ||
                node === clonedWindow.document.documentElement ||
                options.canvas != null
              ) {
                canvas = renderer.canvas;
              } else {
                canvas = crop(renderer.canvas, {
                  width: options.width != null ? options.width : bounds.width,
                  height:
                    options.height != null ? options.height : bounds.height,
                  top: bounds.top,
                  left: bounds.left,
                  x: 0,
                  y: 0,
                });
              }

              cleanupContainer(container, options);
              return canvas;
            });
          }

          function cleanupContainer(container, options) {
            if (options.removeContainer) {
              container.parentNode.removeChild(container);
              log("Cleaned up container");
            }
          }

          function crop(canvas, bounds) {
            var croppedCanvas = document.createElement("canvas");
            var x1 = Math.min(canvas.width - 1, Math.max(0, bounds.left));
            var x2 = Math.min(
              canvas.width,
              Math.max(1, bounds.left + bounds.width)
            );
            var y1 = Math.min(canvas.height - 1, Math.max(0, bounds.top));
            var y2 = Math.min(
              canvas.height,
              Math.max(1, bounds.top + bounds.height)
            );
            croppedCanvas.width = bounds.width;
            croppedCanvas.height = bounds.height;
            var width = x2 - x1;
            var height = y2 - y1;
            log(
              "Cropping canvas at:",
              "left:",
              bounds.left,
              "top:",
              bounds.top,
              "width:",
              width,
              "height:",
              height
            );
            log(
              "Resulting crop with width",
              bounds.width,
              "and height",
              bounds.height,
              "with x",
              x1,
              "and y",
              y1
            );
            croppedCanvas
              .getContext("2d")
              .drawImage(
                canvas,
                x1,
                y1,
                width,
                height,
                bounds.x,
                bounds.y,
                width,
                height
              );
            return croppedCanvas;
          }

          function documentWidth(doc) {
            return Math.max(
              Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth),
              Math.max(doc.body.offsetWidth, doc.documentElement.offsetWidth),
              Math.max(doc.body.clientWidth, doc.documentElement.clientWidth)
            );
          }

          function documentHeight(doc) {
            return Math.max(
              Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight),
              Math.max(doc.body.offsetHeight, doc.documentElement.offsetHeight),
              Math.max(doc.body.clientHeight, doc.documentElement.clientHeight)
            );
          }

          function absoluteUrl(url) {
            var link = document.createElement("a");
            link.href = url;
            link.href = link.href;
            return link;
          }
        },
        {
          "./clone": 2,
          "./imageloader": 11,
          "./log": 13,
          "./nodecontainer": 14,
          "./nodeparser": 15,
          "./proxy": 16,
          "./renderers/canvas": 20,
          "./support": 22,
          "./utils": 26,
        },
      ],
      5: [
        function (_dereq_, module, exports) {
          var log = _dereq_("./log");
          var smallImage = _dereq_("./utils").smallImage;

          function DummyImageContainer(src) {
            this.src = src;
            log("DummyImageContainer for", src);
            if (!this.promise || !this.image) {
              log("Initiating DummyImageContainer");
              DummyImageContainer.prototype.image = new Image();
              var image = this.image;
              DummyImageContainer.prototype.promise = new Promise(function (
                resolve,
                reject
              ) {
                image.onload = resolve;
                image.onerror = reject;
                image.src = smallImage();
                if (image.complete === true) {
                  resolve(image);
                }
              });
            }
          }

          module.exports = DummyImageContainer;
        },
        { "./log": 13, "./utils": 26 },
      ],
      6: [
        function (_dereq_, module, exports) {
          var smallImage = _dereq_("./utils").smallImage;

          function Font(family, size) {
            var container = document.createElement("div"),
              img = document.createElement("img"),
              span = document.createElement("span"),
              sampleText = "Hidden Text",
              baseline,
              middle;

            container.style.visibility = "hidden";
            container.style.fontFamily = family;
            container.style.fontSize = size;
            container.style.margin = 0;
            container.style.padding = 0;

            document.body.appendChild(container);

            img.src = smallImage();
            img.width = 1;
            img.height = 1;

            img.style.margin = 0;
            img.style.padding = 0;
            img.style.verticalAlign = "baseline";

            span.style.fontFamily = family;
            span.style.fontSize = size;
            span.style.margin = 0;
            span.style.padding = 0;

            span.appendChild(document.createTextNode(sampleText));
            container.appendChild(span);
            container.appendChild(img);
            baseline = img.offsetTop - span.offsetTop + 1;

            container.removeChild(span);
            container.appendChild(document.createTextNode(sampleText));

            container.style.lineHeight = "normal";
            img.style.verticalAlign = "super";

            middle = img.offsetTop - container.offsetTop + 1;

            document.body.removeChild(container);

            this.baseline = baseline;
            this.lineWidth = 1;
            this.middle = middle;
          }

          module.exports = Font;
        },
        { "./utils": 26 },
      ],
      7: [
        function (_dereq_, module, exports) {
          var Font = _dereq_("./font");

          function FontMetrics() {
            this.data = {};
          }

          FontMetrics.prototype.getMetrics = function (family, size) {
            if (this.data[family + "-" + size] === undefined) {
              this.data[family + "-" + size] = new Font(family, size);
            }
            return this.data[family + "-" + size];
          };

          module.exports = FontMetrics;
        },
        { "./font": 6 },
      ],
      8: [
        function (_dereq_, module, exports) {
          var utils = _dereq_("./utils");
          var getBounds = utils.getBounds;
          var loadUrlDocument = _dereq_("./proxy").loadUrlDocument;

          function FrameContainer(container, sameOrigin, options) {
            this.image = null;
            this.src = container;
            var self = this;
            var bounds = getBounds(container);
            this.promise = (!sameOrigin
              ? this.proxyLoad(options.proxy, bounds, options)
              : new Promise(function (resolve) {
                  if (
                    container.contentWindow.document.URL === "about:blank" ||
                    container.contentWindow.document.documentElement == null
                  ) {
                    container.contentWindow.onload = container.onload = function () {
                      resolve(container);
                    };
                  } else {
                    resolve(container);
                  }
                })
            )
              .then(function (container) {
                var html2canvas = _dereq_("./core");
                return html2canvas(
                  container.contentWindow.document.documentElement,
                  {
                    type: "view",
                    width: container.width,
                    height: container.height,
                    proxy: options.proxy,
                    javascriptEnabled: options.javascriptEnabled,
                    removeContainer: options.removeContainer,
                    allowTaint: options.allowTaint,
                    imageTimeout: options.imageTimeout / 2,
                  }
                );
              })
              .then(function (canvas) {
                return (self.image = canvas);
              });
          }

          FrameContainer.prototype.proxyLoad = function (
            proxy,
            bounds,
            options
          ) {
            var container = this.src;
            return loadUrlDocument(
              container.src,
              proxy,
              container.ownerDocument,
              bounds.width,
              bounds.height,
              options
            );
          };

          module.exports = FrameContainer;
        },
        { "./core": 4, "./proxy": 16, "./utils": 26 },
      ],
      9: [
        function (_dereq_, module, exports) {
          function GradientContainer(imageData) {
            this.src = imageData.value;
            this.colorStops = [];
            this.type = null;
            this.x0 = 0.5;
            this.y0 = 0.5;
            this.x1 = 0.5;
            this.y1 = 0.5;
            this.promise = Promise.resolve(true);
          }

          GradientContainer.TYPES = {
            LINEAR: 1,
            RADIAL: 2,
          };

          // TODO: support hsl[a], negative %/length values
          // TODO: support <angle> (e.g. -?\d{1,3}(?:\.\d+)deg, etc. : https://developer.mozilla.org/docs/Web/CSS/angle )
          GradientContainer.REGEXP_COLORSTOP = /^\s*(rgba?\(\s*\d{1,3},\s*\d{1,3},\s*\d{1,3}(?:,\s*[0-9\.]+)?\s*\)|[a-z]{3,20}|#[a-f0-9]{3,6})(?:\s+(\d{1,3}(?:\.\d+)?)(%|px)?)?(?:\s|$)/i;

          module.exports = GradientContainer;
        },
        {},
      ],
      10: [
        function (_dereq_, module, exports) {
          function ImageContainer(src, cors) {
            this.src = src;
            this.image = new Image();
            var self = this;
            this.tainted = null;
            this.promise = new Promise(function (resolve, reject) {
              self.image.onload = resolve;
              self.image.onerror = reject;
              if (cors) {
                self.image.crossOrigin = "anonymous";
              }
              self.image.src = src;
              if (self.image.complete === true) {
                resolve(self.image);
              }
            });
          }

          module.exports = ImageContainer;
        },
        {},
      ],
      11: [
        function (_dereq_, module, exports) {
          var log = _dereq_("./log");
          var ImageContainer = _dereq_("./imagecontainer");
          var DummyImageContainer = _dereq_("./dummyimagecontainer");
          var ProxyImageContainer = _dereq_("./proxyimagecontainer");
          var FrameContainer = _dereq_("./framecontainer");
          var SVGContainer = _dereq_("./svgcontainer");
          var SVGNodeContainer = _dereq_("./svgnodecontainer");
          var LinearGradientContainer = _dereq_("./lineargradientcontainer");
          var WebkitGradientContainer = _dereq_("./webkitgradientcontainer");
          var bind = _dereq_("./utils").bind;

          function ImageLoader(options, support) {
            this.link = null;
            this.options = options;
            this.support = support;
            this.origin = this.getOrigin(window.location.href);
          }

          ImageLoader.prototype.findImages = function (nodes) {
            var images = [];
            nodes
              .reduce(function (imageNodes, container) {
                switch (container.node.nodeName) {
                  case "IMG":
                    return imageNodes.concat([
                      {
                        args: [container.node.src],
                        method: "url",
                      },
                    ]);
                  case "svg":
                  case "IFRAME":
                    return imageNodes.concat([
                      {
                        args: [container.node],
                        method: container.node.nodeName,
                      },
                    ]);
                }
                return imageNodes;
              }, [])
              .forEach(this.addImage(images, this.loadImage), this);
            return images;
          };

          ImageLoader.prototype.findBackgroundImage = function (
            images,
            container
          ) {
            container
              .parseBackgroundImages()
              .filter(this.hasImageBackground)
              .forEach(this.addImage(images, this.loadImage), this);
            return images;
          };

          ImageLoader.prototype.addImage = function (images, callback) {
            return function (newImage) {
              newImage.args.forEach(function (image) {
                if (!this.imageExists(images, image)) {
                  images.splice(0, 0, callback.call(this, newImage));
                  log(
                    "Added image #" + images.length,
                    typeof image === "string" ? image.substring(0, 100) : image
                  );
                }
              }, this);
            };
          };

          ImageLoader.prototype.hasImageBackground = function (imageData) {
            return imageData.method !== "none";
          };

          ImageLoader.prototype.loadImage = function (imageData) {
            if (imageData.method === "url") {
              var src = imageData.args[0];
              if (
                this.isSVG(src) &&
                !this.support.svg &&
                !this.options.allowTaint
              ) {
                return new SVGContainer(src);
              } else if (src.match(/data:image\/.*;base64,/i)) {
                return new ImageContainer(
                  src.replace(/url\(['"]{0,}|['"]{0,}\)$/gi, ""),
                  false
                );
              } else if (
                this.isSameOrigin(src) ||
                this.options.allowTaint === true ||
                this.isSVG(src)
              ) {
                return new ImageContainer(src, false);
              } else if (
                this.support.cors &&
                !this.options.allowTaint &&
                this.options.useCORS
              ) {
                return new ImageContainer(src, true);
              } else if (this.options.proxy) {
                return new ProxyImageContainer(src, this.options.proxy);
              } else {
                return new DummyImageContainer(src);
              }
            } else if (imageData.method === "linear-gradient") {
              return new LinearGradientContainer(imageData);
            } else if (imageData.method === "gradient") {
              return new WebkitGradientContainer(imageData);
            } else if (imageData.method === "svg") {
              return new SVGNodeContainer(imageData.args[0], this.support.svg);
            } else if (imageData.method === "IFRAME") {
              return new FrameContainer(
                imageData.args[0],
                this.isSameOrigin(imageData.args[0].src),
                this.options
              );
            } else {
              return new DummyImageContainer(imageData);
            }
          };

          ImageLoader.prototype.isSVG = function (src) {
            return (
              src.substring(src.length - 3).toLowerCase() === "svg" ||
              SVGContainer.prototype.isInline(src)
            );
          };

          ImageLoader.prototype.imageExists = function (images, src) {
            return images.some(function (image) {
              return image.src === src;
            });
          };

          ImageLoader.prototype.isSameOrigin = function (url) {
            return this.getOrigin(url) === this.origin;
          };

          ImageLoader.prototype.getOrigin = function (url) {
            var link = this.link || (this.link = document.createElement("a"));
            link.href = url;
            link.href = link.href; // IE9, LOL! - http://jsfiddle.net/niklasvh/2e48b/
            return link.protocol + link.hostname + link.port;
          };

          ImageLoader.prototype.getPromise = function (container) {
            return this.timeout(container, this.options.imageTimeout)["catch"](
              function () {
                var dummy = new DummyImageContainer(container.src);
                return dummy.promise.then(function (image) {
                  container.image = image;
                });
              }
            );
          };

          ImageLoader.prototype.get = function (src) {
            var found = null;
            return this.images.some(function (img) {
              return (found = img).src === src;
            })
              ? found
              : null;
          };

          ImageLoader.prototype.fetch = function (nodes) {
            this.images = nodes.reduce(
              bind(this.findBackgroundImage, this),
              this.findImages(nodes)
            );
            this.images.forEach(function (image, index) {
              image.promise.then(
                function () {
                  log("Succesfully loaded image #" + (index + 1), image);
                },
                function (e) {
                  log("Failed loading image #" + (index + 1), image, e);
                }
              );
            });
            this.ready = Promise.all(this.images.map(this.getPromise, this));
            log("Finished searching images");
            return this;
          };

          ImageLoader.prototype.timeout = function (container, timeout) {
            var timer;
            var promise = Promise.race([
              container.promise,
              new Promise(function (res, reject) {
                timer = setTimeout(function () {
                  log("Timed out loading image", container);
                  reject(container);
                }, timeout);
              }),
            ]).then(function (container) {
              clearTimeout(timer);
              return container;
            });
            promise["catch"](function () {
              clearTimeout(timer);
            });
            return promise;
          };

          module.exports = ImageLoader;
        },
        {
          "./dummyimagecontainer": 5,
          "./framecontainer": 8,
          "./imagecontainer": 10,
          "./lineargradientcontainer": 12,
          "./log": 13,
          "./proxyimagecontainer": 17,
          "./svgcontainer": 23,
          "./svgnodecontainer": 24,
          "./utils": 26,
          "./webkitgradientcontainer": 27,
        },
      ],
      12: [
        function (_dereq_, module, exports) {
          var GradientContainer = _dereq_("./gradientcontainer");
          var Color = _dereq_("./color");

          function LinearGradientContainer(imageData) {
            GradientContainer.apply(this, arguments);
            this.type = GradientContainer.TYPES.LINEAR;

            var hasDirection =
              LinearGradientContainer.REGEXP_DIRECTION.test(
                imageData.args[0]
              ) || !GradientContainer.REGEXP_COLORSTOP.test(imageData.args[0]);

            if (hasDirection) {
              imageData.args[0]
                .split(/\s+/)
                .reverse()
                .forEach(function (position, index) {
                  switch (position) {
                    case "left":
                      this.x0 = 0;
                      this.x1 = 1;
                      break;
                    case "top":
                      this.y0 = 0;
                      this.y1 = 1;
                      break;
                    case "right":
                      this.x0 = 1;
                      this.x1 = 0;
                      break;
                    case "bottom":
                      this.y0 = 1;
                      this.y1 = 0;
                      break;
                    case "to":
                      var y0 = this.y0;
                      var x0 = this.x0;
                      this.y0 = this.y1;
                      this.x0 = this.x1;
                      this.x1 = x0;
                      this.y1 = y0;
                      break;
                    case "center":
                      break; // centered by default
                    // Firefox internally converts position keywords to percentages:
                    // http://www.w3.org/TR/2010/WD-CSS2-20101207/colors.html#propdef-background-position
                    default:
                      // percentage or absolute length
                      // TODO: support absolute start point positions (e.g., use bounds to convert px to a ratio)
                      var ratio = parseFloat(position, 10) * 1e-2;
                      if (isNaN(ratio)) {
                        // invalid or unhandled value
                        break;
                      }
                      if (index === 0) {
                        this.y0 = ratio;
                        this.y1 = 1 - this.y0;
                      } else {
                        this.x0 = ratio;
                        this.x1 = 1 - this.x0;
                      }
                      break;
                  }
                }, this);
            } else {
              this.y0 = 0;
              this.y1 = 1;
            }

            this.colorStops = imageData.args
              .slice(hasDirection ? 1 : 0)
              .map(function (colorStop) {
                var colorStopMatch = colorStop.match(
                  GradientContainer.REGEXP_COLORSTOP
                );
                var value = +colorStopMatch[2];
                var unit = value === 0 ? "%" : colorStopMatch[3]; // treat "0" as "0%"
                return {
                  color: new Color(colorStopMatch[1]),
                  // TODO: support absolute stop positions (e.g., compute gradient line length & convert px to ratio)
                  stop: unit === "%" ? value / 100 : null,
                };
              });

            if (this.colorStops[0].stop === null) {
              this.colorStops[0].stop = 0;
            }

            if (this.colorStops[this.colorStops.length - 1].stop === null) {
              this.colorStops[this.colorStops.length - 1].stop = 1;
            }

            // calculates and fills-in explicit stop positions when omitted from rule
            this.colorStops.forEach(function (colorStop, index) {
              if (colorStop.stop === null) {
                this.colorStops.slice(index).some(function (find, count) {
                  if (find.stop !== null) {
                    colorStop.stop =
                      (find.stop - this.colorStops[index - 1].stop) /
                        (count + 1) +
                      this.colorStops[index - 1].stop;
                    return true;
                  } else {
                    return false;
                  }
                }, this);
              }
            }, this);
          }

          LinearGradientContainer.prototype = Object.create(
            GradientContainer.prototype
          );

          // TODO: support <angle> (e.g. -?\d{1,3}(?:\.\d+)deg, etc. : https://developer.mozilla.org/docs/Web/CSS/angle )
          LinearGradientContainer.REGEXP_DIRECTION = /^\s*(?:to|left|right|top|bottom|center|\d{1,3}(?:\.\d+)?%?)(?:\s|$)/i;

          module.exports = LinearGradientContainer;
        },
        { "./color": 3, "./gradientcontainer": 9 },
      ],
      13: [
        function (_dereq_, module, exports) {
          var logger = function () {
            if (
              logger.options.logging &&
              window.console &&
              window.console.log
            ) {
              Function.prototype.bind
                .call(window.console.log, window.console)
                .apply(
                  window.console,
                  [
                    Date.now() - logger.options.start + "ms",
                    "html2canvas:",
                  ].concat([].slice.call(arguments, 0))
                );
            }
          };

          logger.options = { logging: false };
          module.exports = logger;
        },
        {},
      ],
      14: [
        function (_dereq_, module, exports) {
          var Color = _dereq_("./color");
          var utils = _dereq_("./utils");
          var getBounds = utils.getBounds;
          var parseBackgrounds = utils.parseBackgrounds;
          var offsetBounds = utils.offsetBounds;

          function NodeContainer(node, parent) {
            this.node = node;
            this.parent = parent;
            this.stack = null;
            this.bounds = null;
            this.borders = null;
            this.clip = [];
            this.backgroundClip = [];
            this.offsetBounds = null;
            this.visible = null;
            this.computedStyles = null;
            this.colors = {};
            this.styles = {};
            this.backgroundImages = null;
            this.transformData = null;
            this.transformMatrix = null;
            this.isPseudoElement = false;
            this.opacity = null;
          }

          NodeContainer.prototype.cloneTo = function (stack) {
            stack.visible = this.visible;
            stack.borders = this.borders;
            stack.bounds = this.bounds;
            stack.clip = this.clip;
            stack.backgroundClip = this.backgroundClip;
            stack.computedStyles = this.computedStyles;
            stack.styles = this.styles;
            stack.backgroundImages = this.backgroundImages;
            stack.opacity = this.opacity;
          };

          NodeContainer.prototype.getOpacity = function () {
            return this.opacity === null
              ? (this.opacity = this.cssFloat("opacity"))
              : this.opacity;
          };

          NodeContainer.prototype.assignStack = function (stack) {
            this.stack = stack;
            stack.children.push(this);
          };

          NodeContainer.prototype.isElementVisible = function () {
            return this.node.nodeType === Node.TEXT_NODE
              ? this.parent.visible
              : this.css("display") !== "none" &&
                  this.css("visibility") !== "hidden" &&
                  !this.node.hasAttribute("data-html2canvas-ignore") &&
                  (this.node.nodeName !== "INPUT" ||
                    this.node.getAttribute("type") !== "hidden");
          };

          NodeContainer.prototype.css = function (attribute) {
            if (!this.computedStyles) {
              this.computedStyles = this.isPseudoElement
                ? this.parent.computedStyle(this.before ? ":before" : ":after")
                : this.computedStyle(null);
            }

            return (
              this.styles[attribute] ||
              (this.styles[attribute] = this.computedStyles[attribute])
            );
          };

          NodeContainer.prototype.prefixedCss = function (attribute) {
            var prefixes = ["webkit", "moz", "ms", "o"];
            var value = this.css(attribute);
            if (value === undefined) {
              prefixes.some(function (prefix) {
                value = this.css(
                  prefix +
                    attribute.substr(0, 1).toUpperCase() +
                    attribute.substr(1)
                );
                return value !== undefined;
              }, this);
            }
            return value === undefined ? null : value;
          };

          NodeContainer.prototype.computedStyle = function (type) {
            return this.node.ownerDocument.defaultView.getComputedStyle(
              this.node,
              type
            );
          };

          NodeContainer.prototype.cssInt = function (attribute) {
            var value = parseInt(this.css(attribute), 10);
            return isNaN(value) ? 0 : value; // borders in old IE are throwing 'medium' for demo.html
          };

          NodeContainer.prototype.color = function (attribute) {
            return (
              this.colors[attribute] ||
              (this.colors[attribute] = new Color(this.css(attribute)))
            );
          };

          NodeContainer.prototype.cssFloat = function (attribute) {
            var value = parseFloat(this.css(attribute));
            return isNaN(value) ? 0 : value;
          };

          NodeContainer.prototype.fontWeight = function () {
            var weight = this.css("fontWeight");
            switch (parseInt(weight, 10)) {
              case 401:
                weight = "bold";
                break;
              case 400:
                weight = "normal";
                break;
            }
            return weight;
          };

          NodeContainer.prototype.parseClip = function () {
            var matches = this.css("clip").match(this.CLIP);
            if (matches) {
              return {
                top: parseInt(matches[1], 10),
                right: parseInt(matches[2], 10),
                bottom: parseInt(matches[3], 10),
                left: parseInt(matches[4], 10),
              };
            }
            return null;
          };

          NodeContainer.prototype.parseBackgroundImages = function () {
            return (
              this.backgroundImages ||
              (this.backgroundImages = parseBackgrounds(
                this.css("backgroundImage")
              ))
            );
          };

          NodeContainer.prototype.cssList = function (property, index) {
            var value = (this.css(property) || "").split(",");
            value = value[index || 0] || value[0] || "auto";
            value = value.trim().split(" ");
            if (value.length === 1) {
              value = [value[0], isPercentage(value[0]) ? "auto" : value[0]];
            }
            return value;
          };

          NodeContainer.prototype.parseBackgroundSize = function (
            bounds,
            image,
            index
          ) {
            var size = this.cssList("backgroundSize", index);
            var width, height;

            if (isPercentage(size[0])) {
              width = (bounds.width * parseFloat(size[0])) / 100;
            } else if (/contain|cover/.test(size[0])) {
              var targetRatio = bounds.width / bounds.height,
                currentRatio = image.width / image.height;
              return (targetRatio < currentRatio) ^ (size[0] === "contain")
                ? { width: bounds.height * currentRatio, height: bounds.height }
                : { width: bounds.width, height: bounds.width / currentRatio };
            } else {
              width = parseInt(size[0], 10);
            }

            if (size[0] === "auto" && size[1] === "auto") {
              height = image.height;
            } else if (size[1] === "auto") {
              height = (width / image.width) * image.height;
            } else if (isPercentage(size[1])) {
              height = (bounds.height * parseFloat(size[1])) / 100;
            } else {
              height = parseInt(size[1], 10);
            }

            if (size[0] === "auto") {
              width = (height / image.height) * image.width;
            }

            return { width: width, height: height };
          };

          NodeContainer.prototype.parseBackgroundPosition = function (
            bounds,
            image,
            index,
            backgroundSize
          ) {
            var position = this.cssList("backgroundPosition", index);
            var left, top;

            if (isPercentage(position[0])) {
              left =
                (bounds.width - (backgroundSize || image).width) *
                (parseFloat(position[0]) / 100);
            } else {
              left = parseInt(position[0], 10);
            }

            if (position[1] === "auto") {
              top = (left / image.width) * image.height;
            } else if (isPercentage(position[1])) {
              top =
                ((bounds.height - (backgroundSize || image).height) *
                  parseFloat(position[1])) /
                100;
            } else {
              top = parseInt(position[1], 10);
            }

            if (position[0] === "auto") {
              left = (top / image.height) * image.width;
            }

            return { left: left, top: top };
          };

          NodeContainer.prototype.parseBackgroundRepeat = function (index) {
            return this.cssList("backgroundRepeat", index)[0];
          };

          NodeContainer.prototype.parseTextShadows = function () {
            var textShadow = this.css("textShadow");
            var results = [];

            if (textShadow && textShadow !== "none") {
              var shadows = textShadow.match(this.TEXT_SHADOW_PROPERTY);
              for (var i = 0; shadows && i < shadows.length; i++) {
                var s = shadows[i].match(this.TEXT_SHADOW_VALUES);
                results.push({
                  color: new Color(s[0]),
                  offsetX: s[1] ? parseFloat(s[1].replace("px", "")) : 0,
                  offsetY: s[2] ? parseFloat(s[2].replace("px", "")) : 0,
                  blur: s[3] ? s[3].replace("px", "") : 0,
                });
              }
            }
            return results;
          };

          NodeContainer.prototype.parseTransform = function () {
            if (!this.transformData) {
              if (this.hasTransform()) {
                var offset = this.parseBounds();
                var origin = this.prefixedCss("transformOrigin")
                  .split(" ")
                  .map(removePx)
                  .map(asFloat);
                origin[0] += offset.left;
                origin[1] += offset.top;
                this.transformData = {
                  origin: origin,
                  matrix: this.parseTransformMatrix(),
                };
              } else {
                this.transformData = {
                  origin: [0, 0],
                  matrix: [1, 0, 0, 1, 0, 0],
                };
              }
            }
            return this.transformData;
          };

          NodeContainer.prototype.parseTransformMatrix = function () {
            if (!this.transformMatrix) {
              var transform = this.prefixedCss("transform");
              var matrix = transform
                ? parseMatrix(transform.match(this.MATRIX_PROPERTY))
                : null;
              this.transformMatrix = matrix ? matrix : [1, 0, 0, 1, 0, 0];
            }
            return this.transformMatrix;
          };

          NodeContainer.prototype.parseBounds = function () {
            return (
              this.bounds ||
              (this.bounds = this.hasTransform()
                ? offsetBounds(this.node)
                : getBounds(this.node))
            );
          };

          NodeContainer.prototype.hasTransform = function () {
            return (
              this.parseTransformMatrix().join(",") !== "1,0,0,1,0,0" ||
              (this.parent && this.parent.hasTransform())
            );
          };

          NodeContainer.prototype.getValue = function () {
            var value = this.node.value || "";
            if (this.node.tagName === "SELECT") {
              value = selectionValue(this.node);
            } else if (this.node.type === "password") {
              value = Array(value.length + 1).join("\u2022"); // jshint ignore:line
            }
            return value.length === 0 ? this.node.placeholder || "" : value;
          };

          NodeContainer.prototype.MATRIX_PROPERTY = /(matrix|matrix3d)\((.+)\)/;
          NodeContainer.prototype.TEXT_SHADOW_PROPERTY = /((rgba|rgb)\([^\)]+\)(\s-?\d+px){0,})/g;
          NodeContainer.prototype.TEXT_SHADOW_VALUES = /(-?\d+px)|(#.+)|(rgb\(.+\))|(rgba\(.+\))/g;
          NodeContainer.prototype.CLIP = /^rect\((\d+)px,? (\d+)px,? (\d+)px,? (\d+)px\)$/;

          function selectionValue(node) {
            var option = node.options[node.selectedIndex || 0];
            return option ? option.text || "" : "";
          }

          function parseMatrix(match) {
            if (match && match[1] === "matrix") {
              return match[2].split(",").map(function (s) {
                return parseFloat(s.trim());
              });
            } else if (match && match[1] === "matrix3d") {
              var matrix3d = match[2].split(",").map(function (s) {
                return parseFloat(s.trim());
              });
              return [
                matrix3d[0],
                matrix3d[1],
                matrix3d[4],
                matrix3d[5],
                matrix3d[12],
                matrix3d[13],
              ];
            }
          }

          function isPercentage(value) {
            return value.toString().indexOf("%") !== -1;
          }

          function removePx(str) {
            return str.replace("px", "");
          }

          function asFloat(str) {
            return parseFloat(str);
          }

          module.exports = NodeContainer;
        },
        { "./color": 3, "./utils": 26 },
      ],
      15: [
        function (_dereq_, module, exports) {
          var log = _dereq_("./log");
          var punycode = _dereq_("punycode");
          var NodeContainer = _dereq_("./nodecontainer");
          var TextContainer = _dereq_("./textcontainer");
          var PseudoElementContainer = _dereq_("./pseudoelementcontainer");
          var FontMetrics = _dereq_("./fontmetrics");
          var Color = _dereq_("./color");
          var StackingContext = _dereq_("./stackingcontext");
          var utils = _dereq_("./utils");
          var bind = utils.bind;
          var getBounds = utils.getBounds;
          var parseBackgrounds = utils.parseBackgrounds;
          var offsetBounds = utils.offsetBounds;

          function NodeParser(
            element,
            renderer,
            support,
            imageLoader,
            options
          ) {
            log("Starting NodeParser");
            this.renderer = renderer;
            this.options = options;
            this.range = null;
            this.support = support;
            this.renderQueue = [];
            this.stack = new StackingContext(
              true,
              1,
              element.ownerDocument,
              null
            );
            var parent = new NodeContainer(element, null);
            if (options.background) {
              renderer.rectangle(
                0,
                0,
                renderer.width,
                renderer.height,
                new Color(options.background)
              );
            }
            if (element === element.ownerDocument.documentElement) {
              // http://www.w3.org/TR/css3-background/#special-backgrounds
              var canvasBackground = new NodeContainer(
                parent.color("backgroundColor").isTransparent()
                  ? element.ownerDocument.body
                  : element.ownerDocument.documentElement,
                null
              );
              renderer.rectangle(
                0,
                0,
                renderer.width,
                renderer.height,
                canvasBackground.color("backgroundColor")
              );
            }
            parent.visibile = parent.isElementVisible();
            this.createPseudoHideStyles(element.ownerDocument);
            this.disableAnimations(element.ownerDocument);
            this.nodes = flatten(
              [parent]
                .concat(this.getChildren(parent))
                .filter(function (container) {
                  return (container.visible = container.isElementVisible());
                })
                .map(this.getPseudoElements, this)
            );
            this.fontMetrics = new FontMetrics();
            log("Fetched nodes, total:", this.nodes.length);
            log("Calculate overflow clips");
            this.calculateOverflowClips();
            log("Start fetching images");
            this.images = imageLoader.fetch(this.nodes.filter(isElement));
            this.ready = this.images.ready.then(
              bind(function () {
                log("Images loaded, starting parsing");
                log("Creating stacking contexts");
                this.createStackingContexts();
                log("Sorting stacking contexts");
                this.sortStackingContexts(this.stack);
                this.parse(this.stack);
                log(
                  "Render queue created with " +
                    this.renderQueue.length +
                    " items"
                );
                return new Promise(
                  bind(function (resolve) {
                    if (!options.async) {
                      this.renderQueue.forEach(this.paint, this);
                      resolve();
                    } else if (typeof options.async === "function") {
                      options.async.call(this, this.renderQueue, resolve);
                    } else if (this.renderQueue.length > 0) {
                      this.renderIndex = 0;
                      this.asyncRenderer(this.renderQueue, resolve);
                    } else {
                      resolve();
                    }
                  }, this)
                );
              }, this)
            );
          }

          NodeParser.prototype.calculateOverflowClips = function () {
            this.nodes.forEach(function (container) {
              if (isElement(container)) {
                if (isPseudoElement(container)) {
                  container.appendToDOM();
                }
                container.borders = this.parseBorders(container);
                var clip =
                  container.css("overflow") === "hidden"
                    ? [container.borders.clip]
                    : [];
                var cssClip = container.parseClip();
                if (
                  cssClip &&
                  ["absolute", "fixed"].indexOf(container.css("position")) !==
                    -1
                ) {
                  clip.push([
                    [
                      "rect",
                      container.bounds.left + cssClip.left,
                      container.bounds.top + cssClip.top,
                      cssClip.right - cssClip.left,
                      cssClip.bottom - cssClip.top,
                    ],
                  ]);
                }
                container.clip = hasParentClip(container)
                  ? container.parent.clip.concat(clip)
                  : clip;
                container.backgroundClip =
                  container.css("overflow") !== "hidden"
                    ? container.clip.concat([container.borders.clip])
                    : container.clip;
                if (isPseudoElement(container)) {
                  container.cleanDOM();
                }
              } else if (isTextNode(container)) {
                container.clip = hasParentClip(container)
                  ? container.parent.clip
                  : [];
              }
              if (!isPseudoElement(container)) {
                container.bounds = null;
              }
            }, this);
          };

          function hasParentClip(container) {
            return container.parent && container.parent.clip.length;
          }

          NodeParser.prototype.asyncRenderer = function (
            queue,
            resolve,
            asyncTimer
          ) {
            asyncTimer = asyncTimer || Date.now();
            this.paint(queue[this.renderIndex++]);
            if (queue.length === this.renderIndex) {
              resolve();
            } else if (asyncTimer + 20 > Date.now()) {
              this.asyncRenderer(queue, resolve, asyncTimer);
            } else {
              setTimeout(
                bind(function () {
                  this.asyncRenderer(queue, resolve);
                }, this),
                0
              );
            }
          };

          NodeParser.prototype.createPseudoHideStyles = function (document) {
            this.createStyles(
              document,
              "." +
                PseudoElementContainer.prototype
                  .PSEUDO_HIDE_ELEMENT_CLASS_BEFORE +
                ':before { content: "" !important; display: none !important; }' +
                "." +
                PseudoElementContainer.prototype
                  .PSEUDO_HIDE_ELEMENT_CLASS_AFTER +
                ':after { content: "" !important; display: none !important; }'
            );
          };

          NodeParser.prototype.disableAnimations = function (document) {
            this.createStyles(
              document,
              "* { -webkit-animation: none !important; -moz-animation: none !important; -o-animation: none !important; animation: none !important; " +
                "-webkit-transition: none !important; -moz-transition: none !important; -o-transition: none !important; transition: none !important;}"
            );
          };

          NodeParser.prototype.createStyles = function (document, styles) {
            var hidePseudoElements = document.createElement("style");
            hidePseudoElements.innerHTML = styles;
            document.body.appendChild(hidePseudoElements);
          };

          NodeParser.prototype.getPseudoElements = function (container) {
            var nodes = [[container]];
            if (container.node.nodeType === Node.ELEMENT_NODE) {
              var before = this.getPseudoElement(container, ":before");
              var after = this.getPseudoElement(container, ":after");

              if (before) {
                nodes.push(before);
              }

              if (after) {
                nodes.push(after);
              }
            }
            return flatten(nodes);
          };

          function toCamelCase(str) {
            return str.replace(/(\-[a-z])/g, function (match) {
              return match.toUpperCase().replace("-", "");
            });
          }

          NodeParser.prototype.getPseudoElement = function (container, type) {
            var style = container.computedStyle(type);
            if (
              !style ||
              !style.content ||
              style.content === "none" ||
              style.content === "-moz-alt-content" ||
              style.display === "none"
            ) {
              return null;
            }

            var content = stripQuotes(style.content);
            var isImage = content.substr(0, 3) === "url";
            var pseudoNode = document.createElement(
              isImage ? "img" : "html2canvaspseudoelement"
            );
            var pseudoContainer = new PseudoElementContainer(
              pseudoNode,
              container,
              type
            );

            for (var i = style.length - 1; i >= 0; i--) {
              var property = toCamelCase(style.item(i));
              pseudoNode.style[property] = style[property];
            }

            pseudoNode.className =
              PseudoElementContainer.prototype
                .PSEUDO_HIDE_ELEMENT_CLASS_BEFORE +
              " " +
              PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER;

            if (isImage) {
              pseudoNode.src = parseBackgrounds(content)[0].args[0];
              return [pseudoContainer];
            } else {
              var text = document.createTextNode(content);
              pseudoNode.appendChild(text);
              return [
                pseudoContainer,
                new TextContainer(text, pseudoContainer),
              ];
            }
          };

          NodeParser.prototype.getChildren = function (parentContainer) {
            return flatten(
              [].filter
                .call(parentContainer.node.childNodes, renderableNode)
                .map(function (node) {
                  var container = [
                    node.nodeType === Node.TEXT_NODE
                      ? new TextContainer(node, parentContainer)
                      : new NodeContainer(node, parentContainer),
                  ].filter(nonIgnoredElement);
                  return node.nodeType === Node.ELEMENT_NODE &&
                    container.length &&
                    node.tagName !== "TEXTAREA"
                    ? container[0].isElementVisible()
                      ? container.concat(this.getChildren(container[0]))
                      : []
                    : container;
                }, this)
            );
          };

          NodeParser.prototype.newStackingContext = function (
            container,
            hasOwnStacking
          ) {
            var stack = new StackingContext(
              hasOwnStacking,
              container.getOpacity(),
              container.node,
              container.parent
            );
            container.cloneTo(stack);
            var parentStack = hasOwnStacking
              ? stack.getParentStack(this)
              : stack.parent.stack;
            parentStack.contexts.push(stack);
            container.stack = stack;
          };

          NodeParser.prototype.createStackingContexts = function () {
            this.nodes.forEach(function (container) {
              if (
                isElement(container) &&
                (this.isRootElement(container) ||
                  hasOpacity(container) ||
                  isPositionedForStacking(container) ||
                  this.isBodyWithTransparentRoot(container) ||
                  container.hasTransform())
              ) {
                this.newStackingContext(container, true);
              } else if (
                isElement(container) &&
                ((isPositioned(container) && zIndex0(container)) ||
                  isInlineBlock(container) ||
                  isFloating(container))
              ) {
                this.newStackingContext(container, false);
              } else {
                container.assignStack(container.parent.stack);
              }
            }, this);
          };

          NodeParser.prototype.isBodyWithTransparentRoot = function (
            container
          ) {
            return (
              container.node.nodeName === "BODY" &&
              container.parent.color("backgroundColor").isTransparent()
            );
          };

          NodeParser.prototype.isRootElement = function (container) {
            return container.parent === null;
          };

          NodeParser.prototype.sortStackingContexts = function (stack) {
            stack.contexts.sort(zIndexSort(stack.contexts.slice(0)));
            stack.contexts.forEach(this.sortStackingContexts, this);
          };

          NodeParser.prototype.parseTextBounds = function (container) {
            return function (text, index, textList) {
              if (
                container.parent.css("textDecoration").substr(0, 4) !==
                  "none" ||
                text.trim().length !== 0
              ) {
                if (
                  this.support.rangeBounds &&
                  !container.parent.hasTransform()
                ) {
                  var offset = textList.slice(0, index).join("").length;
                  return this.getRangeBounds(
                    container.node,
                    offset,
                    text.length
                  );
                } else if (
                  container.node &&
                  typeof container.node.data === "string"
                ) {
                  var replacementNode = container.node.splitText(text.length);
                  var bounds = this.getWrapperBounds(
                    container.node,
                    container.parent.hasTransform()
                  );
                  container.node = replacementNode;
                  return bounds;
                }
              } else if (
                !this.support.rangeBounds ||
                container.parent.hasTransform()
              ) {
                container.node = container.node.splitText(text.length);
              }
              return {};
            };
          };

          NodeParser.prototype.getWrapperBounds = function (node, transform) {
            var wrapper = node.ownerDocument.createElement(
              "html2canvaswrapper"
            );
            var parent = node.parentNode,
              backupText = node.cloneNode(true);

            wrapper.appendChild(node.cloneNode(true));
            parent.replaceChild(wrapper, node);
            var bounds = transform ? offsetBounds(wrapper) : getBounds(wrapper);
            parent.replaceChild(backupText, wrapper);
            return bounds;
          };

          NodeParser.prototype.getRangeBounds = function (
            node,
            offset,
            length
          ) {
            var range =
              this.range || (this.range = node.ownerDocument.createRange());
            range.setStart(node, offset);
            range.setEnd(node, offset + length);
            return range.getBoundingClientRect();
          };

          function ClearTransform() {}

          NodeParser.prototype.parse = function (stack) {
            // http://www.w3.org/TR/CSS21/visuren.html#z-index
            var negativeZindex = stack.contexts.filter(negativeZIndex); // 2. the child stacking contexts with negative stack levels (most negative first).
            var descendantElements = stack.children.filter(isElement);
            var descendantNonFloats = descendantElements.filter(
              not(isFloating)
            );
            var nonInlineNonPositionedDescendants = descendantNonFloats
              .filter(not(isPositioned))
              .filter(not(inlineLevel)); // 3 the in-flow, non-inline-level, non-positioned descendants.
            var nonPositionedFloats = descendantElements
              .filter(not(isPositioned))
              .filter(isFloating); // 4. the non-positioned floats.
            var inFlow = descendantNonFloats
              .filter(not(isPositioned))
              .filter(inlineLevel); // 5. the in-flow, inline-level, non-positioned descendants, including inline tables and inline blocks.
            var stackLevel0 = stack.contexts
              .concat(descendantNonFloats.filter(isPositioned))
              .filter(zIndex0); // 6. the child stacking contexts with stack level 0 and the positioned descendants with stack level 0.
            var text = stack.children.filter(isTextNode).filter(hasText);
            var positiveZindex = stack.contexts.filter(positiveZIndex); // 7. the child stacking contexts with positive stack levels (least positive first).
            negativeZindex
              .concat(nonInlineNonPositionedDescendants)
              .concat(nonPositionedFloats)
              .concat(inFlow)
              .concat(stackLevel0)
              .concat(text)
              .concat(positiveZindex)
              .forEach(function (container) {
                this.renderQueue.push(container);
                if (isStackingContext(container)) {
                  this.parse(container);
                  this.renderQueue.push(new ClearTransform());
                }
              }, this);
          };

          NodeParser.prototype.paint = function (container) {
            try {
              if (container instanceof ClearTransform) {
                this.renderer.ctx.restore();
              } else if (isTextNode(container)) {
                if (isPseudoElement(container.parent)) {
                  container.parent.appendToDOM();
                }
                this.paintText(container);
                if (isPseudoElement(container.parent)) {
                  container.parent.cleanDOM();
                }
              } else {
                this.paintNode(container);
              }
            } catch (e) {
              log(e);
              if (this.options.strict) {
                throw e;
              }
            }
          };

          NodeParser.prototype.paintNode = function (container) {
            if (isStackingContext(container)) {
              this.renderer.setOpacity(container.opacity);
              this.renderer.ctx.save();
              if (container.hasTransform()) {
                this.renderer.setTransform(container.parseTransform());
              }
            }

            if (
              container.node.nodeName === "INPUT" &&
              container.node.type === "checkbox"
            ) {
              this.paintCheckbox(container);
            } else if (
              container.node.nodeName === "INPUT" &&
              container.node.type === "radio"
            ) {
              this.paintRadio(container);
            } else {
              this.paintElement(container);
            }
          };

          NodeParser.prototype.paintElement = function (container) {
            var bounds = container.parseBounds();
            this.renderer.clip(
              container.backgroundClip,
              function () {
                this.renderer.renderBackground(
                  container,
                  bounds,
                  container.borders.borders.map(getWidth)
                );
              },
              this
            );

            this.renderer.clip(
              container.clip,
              function () {
                this.renderer.renderBorders(container.borders.borders);
              },
              this
            );

            this.renderer.clip(
              container.backgroundClip,
              function () {
                switch (container.node.nodeName) {
                  case "svg":
                  case "IFRAME":
                    var imgContainer = this.images.get(container.node);
                    if (imgContainer) {
                      this.renderer.renderImage(
                        container,
                        bounds,
                        container.borders,
                        imgContainer
                      );
                    } else {
                      log(
                        "Error loading <" + container.node.nodeName + ">",
                        container.node
                      );
                    }
                    break;
                  case "IMG":
                    var imageContainer = this.images.get(container.node.src);
                    if (imageContainer) {
                      this.renderer.renderImage(
                        container,
                        bounds,
                        container.borders,
                        imageContainer
                      );
                    } else {
                      log("Error loading <img>", container.node.src);
                    }
                    break;
                  case "CANVAS":
                    this.renderer.renderImage(
                      container,
                      bounds,
                      container.borders,
                      { image: container.node }
                    );
                    break;
                  case "SELECT":
                  case "INPUT":
                  case "TEXTAREA":
                    this.paintFormValue(container);
                    break;
                }
              },
              this
            );
          };

          NodeParser.prototype.paintCheckbox = function (container) {
            var b = container.parseBounds();

            var size = Math.min(b.width, b.height);
            var bounds = {
              width: size - 1,
              height: size - 1,
              top: b.top,
              left: b.left,
            };
            var r = [3, 3];
            var radius = [r, r, r, r];
            var borders = [1, 1, 1, 1].map(function (w) {
              return { color: new Color("#A5A5A5"), width: w };
            });

            var borderPoints = calculateCurvePoints(bounds, radius, borders);

            this.renderer.clip(
              container.backgroundClip,
              function () {
                this.renderer.rectangle(
                  bounds.left + 1,
                  bounds.top + 1,
                  bounds.width - 2,
                  bounds.height - 2,
                  new Color("#DEDEDE")
                );
                this.renderer.renderBorders(
                  calculateBorders(borders, bounds, borderPoints, radius)
                );
                if (container.node.checked) {
                  this.renderer.font(
                    new Color("#424242"),
                    "normal",
                    "normal",
                    "bold",
                    size - 3 + "px",
                    "arial"
                  );
                  this.renderer.text(
                    "\u2714",
                    bounds.left + size / 6,
                    bounds.top + size - 1
                  );
                }
              },
              this
            );
          };

          NodeParser.prototype.paintRadio = function (container) {
            var bounds = container.parseBounds();

            var size = Math.min(bounds.width, bounds.height) - 2;

            this.renderer.clip(
              container.backgroundClip,
              function () {
                this.renderer.circleStroke(
                  bounds.left + 1,
                  bounds.top + 1,
                  size,
                  new Color("#DEDEDE"),
                  1,
                  new Color("#A5A5A5")
                );
                if (container.node.checked) {
                  this.renderer.circle(
                    Math.ceil(bounds.left + size / 4) + 1,
                    Math.ceil(bounds.top + size / 4) + 1,
                    Math.floor(size / 2),
                    new Color("#424242")
                  );
                }
              },
              this
            );
          };

          NodeParser.prototype.paintFormValue = function (container) {
            var value = container.getValue();
            if (value.length > 0) {
              var document = container.node.ownerDocument;
              var wrapper = document.createElement("html2canvaswrapper");
              var properties = [
                "lineHeight",
                "textAlign",
                "fontFamily",
                "fontWeight",
                "fontSize",
                "color",
                "paddingLeft",
                "paddingTop",
                "paddingRight",
                "paddingBottom",
                "width",
                "height",
                "borderLeftStyle",
                "borderTopStyle",
                "borderLeftWidth",
                "borderTopWidth",
                "boxSizing",
                "whiteSpace",
                "wordWrap",
              ];

              properties.forEach(function (property) {
                try {
                  wrapper.style[property] = container.css(property);
                } catch (e) {
                  // Older IE has issues with "border"
                  log(
                    "html2canvas: Parse: Exception caught in renderFormValue: " +
                      e.message
                  );
                }
              });
              var bounds = container.parseBounds();
              wrapper.style.position = "fixed";
              wrapper.style.left = bounds.left + "px";
              wrapper.style.top = bounds.top + "px";
              wrapper.textContent = value;
              document.body.appendChild(wrapper);
              this.paintText(new TextContainer(wrapper.firstChild, container));
              document.body.removeChild(wrapper);
            }
          };

          NodeParser.prototype.paintText = function (container) {
            container.applyTextTransform();
            var characters = punycode.ucs2.decode(container.node.data);
            var textList =
              (!this.options.letterRendering || noLetterSpacing(container)) &&
              !hasUnicode(container.node.data)
                ? getWords(characters)
                : characters.map(function (character) {
                    return punycode.ucs2.encode([character]);
                  });

            var weight = container.parent.fontWeight();
            var size = container.parent.css("fontSize");
            var family = container.parent.css("fontFamily");
            var shadows = container.parent.parseTextShadows();

            this.renderer.font(
              container.parent.color("color"),
              container.parent.css("fontStyle"),
              container.parent.css("fontVariant"),
              weight,
              size,
              family
            );
            if (shadows.length) {
              // TODO: support multiple text shadows
              this.renderer.fontShadow(
                shadows[0].color,
                shadows[0].offsetX,
                shadows[0].offsetY,
                shadows[0].blur
              );
            } else {
              this.renderer.clearShadow();
            }

            this.renderer.clip(
              container.parent.clip,
              function () {
                textList
                  .map(this.parseTextBounds(container), this)
                  .forEach(function (bounds, index) {
                    if (bounds) {
                      this.renderer.text(
                        textList[index],
                        bounds.left,
                        bounds.bottom
                      );
                      this.renderTextDecoration(
                        container.parent,
                        bounds,
                        this.fontMetrics.getMetrics(family, size)
                      );
                    }
                  }, this);
              },
              this
            );
          };

          NodeParser.prototype.renderTextDecoration = function (
            container,
            bounds,
            metrics
          ) {
            switch (container.css("textDecoration").split(" ")[0]) {
              case "underline":
                // Draws a line at the baseline of the font
                // TODO As some browsers display the line as more than 1px if the font-size is big, need to take that into account both in position and size
                this.renderer.rectangle(
                  bounds.left,
                  Math.round(bounds.top + metrics.baseline + metrics.lineWidth),
                  bounds.width,
                  1,
                  container.color("color")
                );
                break;
              case "overline":
                this.renderer.rectangle(
                  bounds.left,
                  Math.round(bounds.top),
                  bounds.width,
                  1,
                  container.color("color")
                );
                break;
              case "line-through":
                // TODO try and find exact position for line-through
                this.renderer.rectangle(
                  bounds.left,
                  Math.ceil(bounds.top + metrics.middle + metrics.lineWidth),
                  bounds.width,
                  1,
                  container.color("color")
                );
                break;
            }
          };

          var borderColorTransforms = {
            inset: [
              ["darken", 0.6],
              ["darken", 0.1],
              ["darken", 0.1],
              ["darken", 0.6],
            ],
          };

          NodeParser.prototype.parseBorders = function (container) {
            var nodeBounds = container.parseBounds();
            var radius = getBorderRadiusData(container);
            var borders = ["Top", "Right", "Bottom", "Left"].map(function (
              side,
              index
            ) {
              var style = container.css("border" + side + "Style");
              var color = container.color("border" + side + "Color");
              if (style === "inset" && color.isBlack()) {
                color = new Color([255, 255, 255, color.a]); // this is wrong, but
              }
              var colorTransform = borderColorTransforms[style]
                ? borderColorTransforms[style][index]
                : null;
              return {
                width: container.cssInt("border" + side + "Width"),
                color: colorTransform
                  ? color[colorTransform[0]](colorTransform[1])
                  : color,
                args: null,
              };
            });
            var borderPoints = calculateCurvePoints(
              nodeBounds,
              radius,
              borders
            );

            return {
              clip: this.parseBackgroundClip(
                container,
                borderPoints,
                borders,
                radius,
                nodeBounds
              ),
              borders: calculateBorders(
                borders,
                nodeBounds,
                borderPoints,
                radius
              ),
            };
          };

          function calculateBorders(borders, nodeBounds, borderPoints, radius) {
            return borders.map(function (border, borderSide) {
              if (border.width > 0) {
                var bx = nodeBounds.left;
                var by = nodeBounds.top;
                var bw = nodeBounds.width;
                var bh = nodeBounds.height - borders[2].width;

                switch (borderSide) {
                  case 0:
                    // top border
                    bh = borders[0].width;
                    border.args = drawSide(
                      {
                        c1: [bx, by],
                        c2: [bx + bw, by],
                        c3: [bx + bw - borders[1].width, by + bh],
                        c4: [bx + borders[3].width, by + bh],
                      },
                      radius[0],
                      radius[1],
                      borderPoints.topLeftOuter,
                      borderPoints.topLeftInner,
                      borderPoints.topRightOuter,
                      borderPoints.topRightInner
                    );
                    break;
                  case 1:
                    // right border
                    bx = nodeBounds.left + nodeBounds.width - borders[1].width;
                    bw = borders[1].width;

                    border.args = drawSide(
                      {
                        c1: [bx + bw, by],
                        c2: [bx + bw, by + bh + borders[2].width],
                        c3: [bx, by + bh],
                        c4: [bx, by + borders[0].width],
                      },
                      radius[1],
                      radius[2],
                      borderPoints.topRightOuter,
                      borderPoints.topRightInner,
                      borderPoints.bottomRightOuter,
                      borderPoints.bottomRightInner
                    );
                    break;
                  case 2:
                    // bottom border
                    by = by + nodeBounds.height - borders[2].width;
                    bh = borders[2].width;
                    border.args = drawSide(
                      {
                        c1: [bx + bw, by + bh],
                        c2: [bx, by + bh],
                        c3: [bx + borders[3].width, by],
                        c4: [bx + bw - borders[3].width, by],
                      },
                      radius[2],
                      radius[3],
                      borderPoints.bottomRightOuter,
                      borderPoints.bottomRightInner,
                      borderPoints.bottomLeftOuter,
                      borderPoints.bottomLeftInner
                    );
                    break;
                  case 3:
                    // left border
                    bw = borders[3].width;
                    border.args = drawSide(
                      {
                        c1: [bx, by + bh + borders[2].width],
                        c2: [bx, by],
                        c3: [bx + bw, by + borders[0].width],
                        c4: [bx + bw, by + bh],
                      },
                      radius[3],
                      radius[0],
                      borderPoints.bottomLeftOuter,
                      borderPoints.bottomLeftInner,
                      borderPoints.topLeftOuter,
                      borderPoints.topLeftInner
                    );
                    break;
                }
              }
              return border;
            });
          }

          NodeParser.prototype.parseBackgroundClip = function (
            container,
            borderPoints,
            borders,
            radius,
            bounds
          ) {
            var backgroundClip = container.css("backgroundClip"),
              borderArgs = [];

            switch (backgroundClip) {
              case "content-box":
              case "padding-box":
                parseCorner(
                  borderArgs,
                  radius[0],
                  radius[1],
                  borderPoints.topLeftInner,
                  borderPoints.topRightInner,
                  bounds.left + borders[3].width,
                  bounds.top + borders[0].width
                );
                parseCorner(
                  borderArgs,
                  radius[1],
                  radius[2],
                  borderPoints.topRightInner,
                  borderPoints.bottomRightInner,
                  bounds.left + bounds.width - borders[1].width,
                  bounds.top + borders[0].width
                );
                parseCorner(
                  borderArgs,
                  radius[2],
                  radius[3],
                  borderPoints.bottomRightInner,
                  borderPoints.bottomLeftInner,
                  bounds.left + bounds.width - borders[1].width,
                  bounds.top + bounds.height - borders[2].width
                );
                parseCorner(
                  borderArgs,
                  radius[3],
                  radius[0],
                  borderPoints.bottomLeftInner,
                  borderPoints.topLeftInner,
                  bounds.left + borders[3].width,
                  bounds.top + bounds.height - borders[2].width
                );
                break;

              default:
                parseCorner(
                  borderArgs,
                  radius[0],
                  radius[1],
                  borderPoints.topLeftOuter,
                  borderPoints.topRightOuter,
                  bounds.left,
                  bounds.top
                );
                parseCorner(
                  borderArgs,
                  radius[1],
                  radius[2],
                  borderPoints.topRightOuter,
                  borderPoints.bottomRightOuter,
                  bounds.left + bounds.width,
                  bounds.top
                );
                parseCorner(
                  borderArgs,
                  radius[2],
                  radius[3],
                  borderPoints.bottomRightOuter,
                  borderPoints.bottomLeftOuter,
                  bounds.left + bounds.width,
                  bounds.top + bounds.height
                );
                parseCorner(
                  borderArgs,
                  radius[3],
                  radius[0],
                  borderPoints.bottomLeftOuter,
                  borderPoints.topLeftOuter,
                  bounds.left,
                  bounds.top + bounds.height
                );
                break;
            }

            return borderArgs;
          };

          function getCurvePoints(x, y, r1, r2) {
            var kappa = 4 * ((Math.sqrt(2) - 1) / 3);
            var ox = r1 * kappa, // control point offset horizontal
              oy = r2 * kappa, // control point offset vertical
              xm = x + r1, // x-middle
              ym = y + r2; // y-middle
            return {
              topLeft: bezierCurve(
                { x: x, y: ym },
                { x: x, y: ym - oy },
                { x: xm - ox, y: y },
                { x: xm, y: y }
              ),
              topRight: bezierCurve(
                { x: x, y: y },
                { x: x + ox, y: y },
                { x: xm, y: ym - oy },
                { x: xm, y: ym }
              ),
              bottomRight: bezierCurve(
                { x: xm, y: y },
                { x: xm, y: y + oy },
                { x: x + ox, y: ym },
                { x: x, y: ym }
              ),
              bottomLeft: bezierCurve(
                { x: xm, y: ym },
                { x: xm - ox, y: ym },
                { x: x, y: y + oy },
                { x: x, y: y }
              ),
            };
          }

          function calculateCurvePoints(bounds, borderRadius, borders) {
            var x = bounds.left,
              y = bounds.top,
              width = bounds.width,
              height = bounds.height,
              tlh =
                borderRadius[0][0] < width / 2 ? borderRadius[0][0] : width / 2,
              tlv =
                borderRadius[0][1] < height / 2
                  ? borderRadius[0][1]
                  : height / 2,
              trh =
                borderRadius[1][0] < width / 2 ? borderRadius[1][0] : width / 2,
              trv =
                borderRadius[1][1] < height / 2
                  ? borderRadius[1][1]
                  : height / 2,
              brh =
                borderRadius[2][0] < width / 2 ? borderRadius[2][0] : width / 2,
              brv =
                borderRadius[2][1] < height / 2
                  ? borderRadius[2][1]
                  : height / 2,
              blh =
                borderRadius[3][0] < width / 2 ? borderRadius[3][0] : width / 2,
              blv =
                borderRadius[3][1] < height / 2
                  ? borderRadius[3][1]
                  : height / 2;

            var topWidth = width - trh,
              rightHeight = height - brv,
              bottomWidth = width - brh,
              leftHeight = height - blv;

            return {
              topLeftOuter: getCurvePoints(x, y, tlh, tlv).topLeft.subdivide(
                0.5
              ),
              topLeftInner: getCurvePoints(
                x + borders[3].width,
                y + borders[0].width,
                Math.max(0, tlh - borders[3].width),
                Math.max(0, tlv - borders[0].width)
              ).topLeft.subdivide(0.5),
              topRightOuter: getCurvePoints(
                x + topWidth,
                y,
                trh,
                trv
              ).topRight.subdivide(0.5),
              topRightInner: getCurvePoints(
                x + Math.min(topWidth, width + borders[3].width),
                y + borders[0].width,
                topWidth > width + borders[3].width
                  ? 0
                  : trh - borders[3].width,
                trv - borders[0].width
              ).topRight.subdivide(0.5),
              bottomRightOuter: getCurvePoints(
                x + bottomWidth,
                y + rightHeight,
                brh,
                brv
              ).bottomRight.subdivide(0.5),
              bottomRightInner: getCurvePoints(
                x + Math.min(bottomWidth, width - borders[3].width),
                y + Math.min(rightHeight, height + borders[0].width),
                Math.max(0, brh - borders[1].width),
                brv - borders[2].width
              ).bottomRight.subdivide(0.5),
              bottomLeftOuter: getCurvePoints(
                x,
                y + leftHeight,
                blh,
                blv
              ).bottomLeft.subdivide(0.5),
              bottomLeftInner: getCurvePoints(
                x + borders[3].width,
                y + leftHeight,
                Math.max(0, blh - borders[3].width),
                blv - borders[2].width
              ).bottomLeft.subdivide(0.5),
            };
          }

          function bezierCurve(start, startControl, endControl, end) {
            var lerp = function (a, b, t) {
              return {
                x: a.x + (b.x - a.x) * t,
                y: a.y + (b.y - a.y) * t,
              };
            };

            return {
              start: start,
              startControl: startControl,
              endControl: endControl,
              end: end,
              subdivide: function (t) {
                var ab = lerp(start, startControl, t),
                  bc = lerp(startControl, endControl, t),
                  cd = lerp(endControl, end, t),
                  abbc = lerp(ab, bc, t),
                  bccd = lerp(bc, cd, t),
                  dest = lerp(abbc, bccd, t);
                return [
                  bezierCurve(start, ab, abbc, dest),
                  bezierCurve(dest, bccd, cd, end),
                ];
              },
              curveTo: function (borderArgs) {
                borderArgs.push([
                  "bezierCurve",
                  startControl.x,
                  startControl.y,
                  endControl.x,
                  endControl.y,
                  end.x,
                  end.y,
                ]);
              },
              curveToReversed: function (borderArgs) {
                borderArgs.push([
                  "bezierCurve",
                  endControl.x,
                  endControl.y,
                  startControl.x,
                  startControl.y,
                  start.x,
                  start.y,
                ]);
              },
            };
          }

          function drawSide(
            borderData,
            radius1,
            radius2,
            outer1,
            inner1,
            outer2,
            inner2
          ) {
            var borderArgs = [];

            if (radius1[0] > 0 || radius1[1] > 0) {
              borderArgs.push(["line", outer1[1].start.x, outer1[1].start.y]);
              outer1[1].curveTo(borderArgs);
            } else {
              borderArgs.push(["line", borderData.c1[0], borderData.c1[1]]);
            }

            if (radius2[0] > 0 || radius2[1] > 0) {
              borderArgs.push(["line", outer2[0].start.x, outer2[0].start.y]);
              outer2[0].curveTo(borderArgs);
              borderArgs.push(["line", inner2[0].end.x, inner2[0].end.y]);
              inner2[0].curveToReversed(borderArgs);
            } else {
              borderArgs.push(["line", borderData.c2[0], borderData.c2[1]]);
              borderArgs.push(["line", borderData.c3[0], borderData.c3[1]]);
            }

            if (radius1[0] > 0 || radius1[1] > 0) {
              borderArgs.push(["line", inner1[1].end.x, inner1[1].end.y]);
              inner1[1].curveToReversed(borderArgs);
            } else {
              borderArgs.push(["line", borderData.c4[0], borderData.c4[1]]);
            }

            return borderArgs;
          }

          function parseCorner(
            borderArgs,
            radius1,
            radius2,
            corner1,
            corner2,
            x,
            y
          ) {
            if (radius1[0] > 0 || radius1[1] > 0) {
              borderArgs.push(["line", corner1[0].start.x, corner1[0].start.y]);
              corner1[0].curveTo(borderArgs);
              corner1[1].curveTo(borderArgs);
            } else {
              borderArgs.push(["line", x, y]);
            }

            if (radius2[0] > 0 || radius2[1] > 0) {
              borderArgs.push(["line", corner2[0].start.x, corner2[0].start.y]);
            }
          }

          function negativeZIndex(container) {
            return container.cssInt("zIndex") < 0;
          }

          function positiveZIndex(container) {
            return container.cssInt("zIndex") > 0;
          }

          function zIndex0(container) {
            return container.cssInt("zIndex") === 0;
          }

          function inlineLevel(container) {
            return (
              ["inline", "inline-block", "inline-table"].indexOf(
                container.css("display")
              ) !== -1
            );
          }

          function isStackingContext(container) {
            return container instanceof StackingContext;
          }

          function hasText(container) {
            return container.node.data.trim().length > 0;
          }

          function noLetterSpacing(container) {
            return /^(normal|none|0px)$/.test(
              container.parent.css("letterSpacing")
            );
          }

          function getBorderRadiusData(container) {
            return ["TopLeft", "TopRight", "BottomRight", "BottomLeft"].map(
              function (side) {
                var value = container.css("border" + side + "Radius");
                var arr = value.split(" ");
                if (arr.length <= 1) {
                  arr[1] = arr[0];
                }
                return arr.map(asInt);
              }
            );
          }

          function renderableNode(node) {
            return (
              node.nodeType === Node.TEXT_NODE ||
              node.nodeType === Node.ELEMENT_NODE
            );
          }

          function isPositionedForStacking(container) {
            var position = container.css("position");
            var zIndex =
              ["absolute", "relative", "fixed"].indexOf(position) !== -1
                ? container.css("zIndex")
                : "auto";
            return zIndex !== "auto";
          }

          function isPositioned(container) {
            return container.css("position") !== "static";
          }

          function isFloating(container) {
            return container.css("float") !== "none";
          }

          function isInlineBlock(container) {
            return (
              ["inline-block", "inline-table"].indexOf(
                container.css("display")
              ) !== -1
            );
          }

          function not(callback) {
            var context = this;
            return function () {
              return !callback.apply(context, arguments);
            };
          }

          function isElement(container) {
            return container.node.nodeType === Node.ELEMENT_NODE;
          }

          function isPseudoElement(container) {
            return container.isPseudoElement === true;
          }

          function isTextNode(container) {
            return container.node.nodeType === Node.TEXT_NODE;
          }

          function zIndexSort(contexts) {
            return function (a, b) {
              return (
                a.cssInt("zIndex") +
                contexts.indexOf(a) / contexts.length -
                (b.cssInt("zIndex") + contexts.indexOf(b) / contexts.length)
              );
            };
          }

          function hasOpacity(container) {
            return container.getOpacity() < 1;
          }

          function asInt(value) {
            return parseInt(value, 10);
          }

          function getWidth(border) {
            return border.width;
          }

          function nonIgnoredElement(nodeContainer) {
            return (
              nodeContainer.node.nodeType !== Node.ELEMENT_NODE ||
              ["SCRIPT", "HEAD", "TITLE", "OBJECT", "BR", "OPTION"].indexOf(
                nodeContainer.node.nodeName
              ) === -1
            );
          }

          function flatten(arrays) {
            return [].concat.apply([], arrays);
          }

          function stripQuotes(content) {
            var first = content.substr(0, 1);
            return first === content.substr(content.length - 1) &&
              first.match(/'|"/)
              ? content.substr(1, content.length - 2)
              : content;
          }

          function getWords(characters) {
            var words = [],
              i = 0,
              onWordBoundary = false,
              word;
            while (characters.length) {
              if (isWordBoundary(characters[i]) === onWordBoundary) {
                word = characters.splice(0, i);
                if (word.length) {
                  words.push(punycode.ucs2.encode(word));
                }
                onWordBoundary = !onWordBoundary;
                i = 0;
              } else {
                i++;
              }

              if (i >= characters.length) {
                word = characters.splice(0, i);
                if (word.length) {
                  words.push(punycode.ucs2.encode(word));
                }
              }
            }
            return words;
          }

          function isWordBoundary(characterCode) {
            return (
              [
                32, // <space>
                13, // \r
                10, // \n
                9, // \t
                45, // -
              ].indexOf(characterCode) !== -1
            );
          }

          function hasUnicode(string) {
            return /[^\u0000-\u00ff]/.test(string);
          }

          module.exports = NodeParser;
        },
        {
          "./color": 3,
          "./fontmetrics": 7,
          "./log": 13,
          "./nodecontainer": 14,
          "./pseudoelementcontainer": 18,
          "./stackingcontext": 21,
          "./textcontainer": 25,
          "./utils": 26,
          punycode: 1,
        },
      ],
      16: [
        function (_dereq_, module, exports) {
          var XHR = _dereq_("./xhr");
          var utils = _dereq_("./utils");
          var log = _dereq_("./log");
          var createWindowClone = _dereq_("./clone");
          var decode64 = utils.decode64;

          function Proxy(src, proxyUrl, document) {
            var supportsCORS = "withCredentials" in new XMLHttpRequest();
            if (!proxyUrl) {
              return Promise.reject("No proxy configured");
            }
            var callback = createCallback(supportsCORS);
            var url = createProxyUrl(proxyUrl, src, callback);

            return supportsCORS
              ? XHR(url)
              : jsonp(document, url, callback).then(function (response) {
                  return decode64(response.content);
                });
          }
          var proxyCount = 0;

          function ProxyURL(src, proxyUrl, document) {
            var supportsCORSImage = "crossOrigin" in new Image();
            var callback = createCallback(supportsCORSImage);
            var url = createProxyUrl(proxyUrl, src, callback);
            return supportsCORSImage
              ? Promise.resolve(url)
              : jsonp(document, url, callback).then(function (response) {
                  return (
                    "data:" + response.type + ";base64," + response.content
                  );
                });
          }

          function jsonp(document, url, callback) {
            return new Promise(function (resolve, reject) {
              var s = document.createElement("script");
              var cleanup = function () {
                delete window.html2canvas.proxy[callback];
                document.body.removeChild(s);
              };
              window.html2canvas.proxy[callback] = function (response) {
                cleanup();
                resolve(response);
              };
              s.src = url;
              s.onerror = function (e) {
                cleanup();
                reject(e);
              };
              document.body.appendChild(s);
            });
          }

          function createCallback(useCORS) {
            return !useCORS
              ? "html2canvas_" +
                  Date.now() +
                  "_" +
                  ++proxyCount +
                  "_" +
                  Math.round(Math.random() * 100000)
              : "";
          }

          function createProxyUrl(proxyUrl, src, callback) {
            return (
              proxyUrl +
              "?url=" +
              encodeURIComponent(src) +
              (callback.length ? "&callback=html2canvas.proxy." + callback : "")
            );
          }

          function documentFromHTML(src) {
            return function (html) {
              var parser = new DOMParser(),
                doc;
              try {
                doc = parser.parseFromString(html, "text/html");
              } catch (e) {
                log(
                  "DOMParser not supported, falling back to createHTMLDocument"
                );
                doc = document.implementation.createHTMLDocument("");
                try {
                  doc.open();
                  doc.write(html);
                  doc.close();
                } catch (ee) {
                  log(
                    "createHTMLDocument write not supported, falling back to document.body.innerHTML"
                  );
                  doc.body.innerHTML = html; // ie9 doesnt support writing to documentElement
                }
              }

              var b = doc.querySelector("base");
              if (!b || !b.href.host) {
                var base = doc.createElement("base");
                base.href = src;
                doc.head.insertBefore(base, doc.head.firstChild);
              }

              return doc;
            };
          }

          function loadUrlDocument(
            src,
            proxy,
            document,
            width,
            height,
            options
          ) {
            return new Proxy(src, proxy, window.document)
              .then(documentFromHTML(src))
              .then(function (doc) {
                return createWindowClone(
                  doc,
                  document,
                  width,
                  height,
                  options,
                  0,
                  0
                );
              });
          }

          exports.Proxy = Proxy;
          exports.ProxyURL = ProxyURL;
          exports.loadUrlDocument = loadUrlDocument;
        },
        { "./clone": 2, "./log": 13, "./utils": 26, "./xhr": 28 },
      ],
      17: [
        function (_dereq_, module, exports) {
          var ProxyURL = _dereq_("./proxy").ProxyURL;

          function ProxyImageContainer(src, proxy) {
            var link = document.createElement("a");
            link.href = src;
            src = link.href;
            this.src = src;
            this.image = new Image();
            var self = this;
            this.promise = new Promise(function (resolve, reject) {
              self.image.crossOrigin = "Anonymous";
              self.image.onload = resolve;
              self.image.onerror = reject;

              new ProxyURL(src, proxy, document)
                .then(function (url) {
                  self.image.src = url;
                })
                ["catch"](reject);
            });
          }

          module.exports = ProxyImageContainer;
        },
        { "./proxy": 16 },
      ],
      18: [
        function (_dereq_, module, exports) {
          var NodeContainer = _dereq_("./nodecontainer");

          function PseudoElementContainer(node, parent, type) {
            NodeContainer.call(this, node, parent);
            this.isPseudoElement = true;
            this.before = type === ":before";
          }

          PseudoElementContainer.prototype.cloneTo = function (stack) {
            PseudoElementContainer.prototype.cloneTo.call(this, stack);
            stack.isPseudoElement = true;
            stack.before = this.before;
          };

          PseudoElementContainer.prototype = Object.create(
            NodeContainer.prototype
          );

          PseudoElementContainer.prototype.appendToDOM = function () {
            if (this.before) {
              this.parent.node.insertBefore(
                this.node,
                this.parent.node.firstChild
              );
            } else {
              this.parent.node.appendChild(this.node);
            }
            this.parent.node.className += " " + this.getHideClass();
          };

          PseudoElementContainer.prototype.cleanDOM = function () {
            this.node.parentNode.removeChild(this.node);
            this.parent.node.className = this.parent.node.className.replace(
              this.getHideClass(),
              ""
            );
          };

          PseudoElementContainer.prototype.getHideClass = function () {
            return this[
              "PSEUDO_HIDE_ELEMENT_CLASS_" + (this.before ? "BEFORE" : "AFTER")
            ];
          };

          PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE =
            "___html2canvas___pseudoelement_before";
          PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER =
            "___html2canvas___pseudoelement_after";

          module.exports = PseudoElementContainer;
        },
        { "./nodecontainer": 14 },
      ],
      19: [
        function (_dereq_, module, exports) {
          var log = _dereq_("./log");

          function Renderer(width, height, images, options, document) {
            this.width = width;
            this.height = height;
            this.images = images;
            this.options = options;
            this.document = document;
          }

          Renderer.prototype.renderImage = function (
            container,
            bounds,
            borderData,
            imageContainer
          ) {
            var paddingLeft = container.cssInt("paddingLeft"),
              paddingTop = container.cssInt("paddingTop"),
              paddingRight = container.cssInt("paddingRight"),
              paddingBottom = container.cssInt("paddingBottom"),
              borders = borderData.borders;

            var width =
              bounds.width -
              (borders[1].width +
                borders[3].width +
                paddingLeft +
                paddingRight);
            var height =
              bounds.height -
              (borders[0].width +
                borders[2].width +
                paddingTop +
                paddingBottom);
            this.drawImage(
              imageContainer,
              0,
              0,
              imageContainer.image.width || width,
              imageContainer.image.height || height,
              bounds.left + paddingLeft + borders[3].width,
              bounds.top + paddingTop + borders[0].width,
              width,
              height
            );
          };

          Renderer.prototype.renderBackground = function (
            container,
            bounds,
            borderData
          ) {
            if (bounds.height > 0 && bounds.width > 0) {
              this.renderBackgroundColor(container, bounds);
              this.renderBackgroundImage(container, bounds, borderData);
            }
          };

          Renderer.prototype.renderBackgroundColor = function (
            container,
            bounds
          ) {
            var color = container.color("backgroundColor");
            if (!color.isTransparent()) {
              this.rectangle(
                bounds.left,
                bounds.top,
                bounds.width,
                bounds.height,
                color
              );
            }
          };

          Renderer.prototype.renderBorders = function (borders) {
            borders.forEach(this.renderBorder, this);
          };

          Renderer.prototype.renderBorder = function (data) {
            if (!data.color.isTransparent() && data.args !== null) {
              this.drawShape(data.args, data.color);
            }
          };

          Renderer.prototype.renderBackgroundImage = function (
            container,
            bounds,
            borderData
          ) {
            var backgroundImages = container.parseBackgroundImages();
            backgroundImages
              .reverse()
              .forEach(function (backgroundImage, index, arr) {
                switch (backgroundImage.method) {
                  case "url":
                    var image = this.images.get(backgroundImage.args[0]);
                    if (image) {
                      this.renderBackgroundRepeating(
                        container,
                        bounds,
                        image,
                        arr.length - (index + 1),
                        borderData
                      );
                    } else {
                      log(
                        "Error loading background-image",
                        backgroundImage.args[0]
                      );
                    }
                    break;
                  case "linear-gradient":
                  case "gradient":
                    var gradientImage = this.images.get(backgroundImage.value);
                    if (gradientImage) {
                      this.renderBackgroundGradient(
                        gradientImage,
                        bounds,
                        borderData
                      );
                    } else {
                      log(
                        "Error loading background-image",
                        backgroundImage.args[0]
                      );
                    }
                    break;
                  case "none":
                    break;
                  default:
                    log(
                      "Unknown background-image type",
                      backgroundImage.args[0]
                    );
                }
              }, this);
          };

          Renderer.prototype.renderBackgroundRepeating = function (
            container,
            bounds,
            imageContainer,
            index,
            borderData
          ) {
            var size = container.parseBackgroundSize(
              bounds,
              imageContainer.image,
              index
            );
            var position = container.parseBackgroundPosition(
              bounds,
              imageContainer.image,
              index,
              size
            );
            var repeat = container.parseBackgroundRepeat(index);
            switch (repeat) {
              case "repeat-x":
              case "repeat no-repeat":
                this.backgroundRepeatShape(
                  imageContainer,
                  position,
                  size,
                  bounds,
                  bounds.left + borderData[3],
                  bounds.top + position.top + borderData[0],
                  99999,
                  size.height,
                  borderData
                );
                break;
              case "repeat-y":
              case "no-repeat repeat":
                this.backgroundRepeatShape(
                  imageContainer,
                  position,
                  size,
                  bounds,
                  bounds.left + position.left + borderData[3],
                  bounds.top + borderData[0],
                  size.width,
                  99999,
                  borderData
                );
                break;
              case "no-repeat":
                this.backgroundRepeatShape(
                  imageContainer,
                  position,
                  size,
                  bounds,
                  bounds.left + position.left + borderData[3],
                  bounds.top + position.top + borderData[0],
                  size.width,
                  size.height,
                  borderData
                );
                break;
              default:
                this.renderBackgroundRepeat(
                  imageContainer,
                  position,
                  size,
                  { top: bounds.top, left: bounds.left },
                  borderData[3],
                  borderData[0]
                );
                break;
            }
          };

          module.exports = Renderer;
        },
        { "./log": 13 },
      ],
      20: [
        function (_dereq_, module, exports) {
          var Renderer = _dereq_("../renderer");
          var LinearGradientContainer = _dereq_("../lineargradientcontainer");
          var log = _dereq_("../log");

          function CanvasRenderer(width, height) {
            Renderer.apply(this, arguments);
            this.canvas =
              this.options.canvas || this.document.createElement("canvas");
            if (!this.options.canvas) {
              this.canvas.width = width;
              this.canvas.height = height;
            }
            this.ctx = this.canvas.getContext("2d");
            this.taintCtx = this.document
              .createElement("canvas")
              .getContext("2d");
            this.ctx.textBaseline = "bottom";
            this.variables = {};
            log("Initialized CanvasRenderer with size", width, "x", height);
          }

          CanvasRenderer.prototype = Object.create(Renderer.prototype);

          CanvasRenderer.prototype.setFillStyle = function (fillStyle) {
            this.ctx.fillStyle =
              typeof fillStyle === "object" && !!fillStyle.isColor
                ? fillStyle.toString()
                : fillStyle;
            return this.ctx;
          };

          CanvasRenderer.prototype.rectangle = function (
            left,
            top,
            width,
            height,
            color
          ) {
            this.setFillStyle(color).fillRect(left, top, width, height);
          };

          CanvasRenderer.prototype.circle = function (left, top, size, color) {
            this.setFillStyle(color);
            this.ctx.beginPath();
            this.ctx.arc(
              left + size / 2,
              top + size / 2,
              size / 2,
              0,
              Math.PI * 2,
              true
            );
            this.ctx.closePath();
            this.ctx.fill();
          };

          CanvasRenderer.prototype.circleStroke = function (
            left,
            top,
            size,
            color,
            stroke,
            strokeColor
          ) {
            this.circle(left, top, size, color);
            this.ctx.strokeStyle = strokeColor.toString();
            this.ctx.stroke();
          };

          CanvasRenderer.prototype.drawShape = function (shape, color) {
            this.shape(shape);
            this.setFillStyle(color).fill();
          };

          CanvasRenderer.prototype.taints = function (imageContainer) {
            if (imageContainer.tainted === null) {
              this.taintCtx.drawImage(imageContainer.image, 0, 0);
              try {
                this.taintCtx.getImageData(0, 0, 1, 1);
                imageContainer.tainted = false;
              } catch (e) {
                this.taintCtx = document
                  .createElement("canvas")
                  .getContext("2d");
                imageContainer.tainted = true;
              }
            }

            return imageContainer.tainted;
          };

          CanvasRenderer.prototype.drawImage = function (
            imageContainer,
            sx,
            sy,
            sw,
            sh,
            dx,
            dy,
            dw,
            dh
          ) {
            if (!this.taints(imageContainer) || this.options.allowTaint) {
              this.ctx.drawImage(
                imageContainer.image,
                sx,
                sy,
                sw,
                sh,
                dx,
                dy,
                dw,
                dh
              );
            }
          };

          CanvasRenderer.prototype.clip = function (shapes, callback, context) {
            this.ctx.save();
            shapes.filter(hasEntries).forEach(function (shape) {
              this.shape(shape).clip();
            }, this);
            callback.call(context);
            this.ctx.restore();
          };

          CanvasRenderer.prototype.shape = function (shape) {
            this.ctx.beginPath();
            shape.forEach(function (point, index) {
              if (point[0] === "rect") {
                this.ctx.rect.apply(this.ctx, point.slice(1));
              } else {
                this.ctx[index === 0 ? "moveTo" : point[0] + "To"].apply(
                  this.ctx,
                  point.slice(1)
                );
              }
            }, this);
            this.ctx.closePath();
            return this.ctx;
          };

          CanvasRenderer.prototype.font = function (
            color,
            style,
            variant,
            weight,
            size,
            family
          ) {
            this.setFillStyle(color).font = [
              style,
              variant,
              weight,
              size,
              family,
            ]
              .join(" ")
              .split(",")[0];
          };

          CanvasRenderer.prototype.fontShadow = function (
            color,
            offsetX,
            offsetY,
            blur
          ) {
            this.setVariable("shadowColor", color.toString())
              .setVariable("shadowOffsetY", offsetX)
              .setVariable("shadowOffsetX", offsetY)
              .setVariable("shadowBlur", blur);
          };

          CanvasRenderer.prototype.clearShadow = function () {
            this.setVariable("shadowColor", "rgba(0,0,0,0)");
          };

          CanvasRenderer.prototype.setOpacity = function (opacity) {
            this.ctx.globalAlpha = opacity;
          };

          CanvasRenderer.prototype.setTransform = function (transform) {
            this.ctx.translate(transform.origin[0], transform.origin[1]);
            this.ctx.transform.apply(this.ctx, transform.matrix);
            this.ctx.translate(-transform.origin[0], -transform.origin[1]);
          };

          CanvasRenderer.prototype.setVariable = function (property, value) {
            if (this.variables[property] !== value) {
              this.variables[property] = this.ctx[property] = value;
            }

            return this;
          };

          CanvasRenderer.prototype.text = function (text, left, bottom) {
            this.ctx.fillText(text, left, bottom);
          };

          CanvasRenderer.prototype.backgroundRepeatShape = function (
            imageContainer,
            backgroundPosition,
            size,
            bounds,
            left,
            top,
            width,
            height,
            borderData
          ) {
            var shape = [
              ["line", Math.round(left), Math.round(top)],
              ["line", Math.round(left + width), Math.round(top)],
              ["line", Math.round(left + width), Math.round(height + top)],
              ["line", Math.round(left), Math.round(height + top)],
            ];
            this.clip(
              [shape],
              function () {
                this.renderBackgroundRepeat(
                  imageContainer,
                  backgroundPosition,
                  size,
                  bounds,
                  borderData[3],
                  borderData[0]
                );
              },
              this
            );
          };

          CanvasRenderer.prototype.renderBackgroundRepeat = function (
            imageContainer,
            backgroundPosition,
            size,
            bounds,
            borderLeft,
            borderTop
          ) {
            var offsetX = Math.round(
                bounds.left + backgroundPosition.left + borderLeft
              ),
              offsetY = Math.round(
                bounds.top + backgroundPosition.top + borderTop
              );
            this.setFillStyle(
              this.ctx.createPattern(
                this.resizeImage(imageContainer, size),
                "repeat"
              )
            );
            this.ctx.translate(offsetX, offsetY);
            this.ctx.fill();
            this.ctx.translate(-offsetX, -offsetY);
          };

          CanvasRenderer.prototype.renderBackgroundGradient = function (
            gradientImage,
            bounds
          ) {
            if (gradientImage instanceof LinearGradientContainer) {
              var gradient = this.ctx.createLinearGradient(
                bounds.left + bounds.width * gradientImage.x0,
                bounds.top + bounds.height * gradientImage.y0,
                bounds.left + bounds.width * gradientImage.x1,
                bounds.top + bounds.height * gradientImage.y1
              );
              gradientImage.colorStops.forEach(function (colorStop) {
                gradient.addColorStop(
                  colorStop.stop,
                  colorStop.color.toString()
                );
              });
              this.rectangle(
                bounds.left,
                bounds.top,
                bounds.width,
                bounds.height,
                gradient
              );
            }
          };

          CanvasRenderer.prototype.resizeImage = function (
            imageContainer,
            size
          ) {
            var image = imageContainer.image;
            if (image.width === size.width && image.height === size.height) {
              return image;
            }

            var ctx,
              canvas = document.createElement("canvas");
            canvas.width = size.width;
            canvas.height = size.height;
            ctx = canvas.getContext("2d");
            ctx.drawImage(
              image,
              0,
              0,
              image.width,
              image.height,
              0,
              0,
              size.width,
              size.height
            );
            return canvas;
          };

          function hasEntries(array) {
            return array.length > 0;
          }

          module.exports = CanvasRenderer;
        },
        { "../lineargradientcontainer": 12, "../log": 13, "../renderer": 19 },
      ],
      21: [
        function (_dereq_, module, exports) {
          var NodeContainer = _dereq_("./nodecontainer");

          function StackingContext(hasOwnStacking, opacity, element, parent) {
            NodeContainer.call(this, element, parent);
            this.ownStacking = hasOwnStacking;
            this.contexts = [];
            this.children = [];
            this.opacity =
              (this.parent ? this.parent.stack.opacity : 1) * opacity;
          }

          StackingContext.prototype = Object.create(NodeContainer.prototype);

          StackingContext.prototype.getParentStack = function (context) {
            var parentStack = this.parent ? this.parent.stack : null;
            return parentStack
              ? parentStack.ownStacking
                ? parentStack
                : parentStack.getParentStack(context)
              : context.stack;
          };

          module.exports = StackingContext;
        },
        { "./nodecontainer": 14 },
      ],
      22: [
        function (_dereq_, module, exports) {
          function Support(document) {
            this.rangeBounds = this.testRangeBounds(document);
            this.cors = this.testCORS();
            this.svg = this.testSVG();
          }

          Support.prototype.testRangeBounds = function (document) {
            var range,
              testElement,
              rangeBounds,
              rangeHeight,
              support = false;

            if (document.createRange) {
              range = document.createRange();
              if (range.getBoundingClientRect) {
                testElement = document.createElement("boundtest");
                testElement.style.height = "123px";
                testElement.style.display = "block";
                document.body.appendChild(testElement);

                range.selectNode(testElement);
                rangeBounds = range.getBoundingClientRect();
                rangeHeight = rangeBounds.height;

                if (rangeHeight === 123) {
                  support = true;
                }
                document.body.removeChild(testElement);
              }
            }

            return support;
          };

          Support.prototype.testCORS = function () {
            return typeof new Image().crossOrigin !== "undefined";
          };

          Support.prototype.testSVG = function () {
            var img = new Image();
            var canvas = document.createElement("canvas");
            var ctx = canvas.getContext("2d");
            img.src =
              "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'></svg>";

            try {
              ctx.drawImage(img, 0, 0);
              canvas.toDataURL();
            } catch (e) {
              return false;
            }
            return true;
          };

          module.exports = Support;
        },
        {},
      ],
      23: [
        function (_dereq_, module, exports) {
          var XHR = _dereq_("./xhr");
          var decode64 = _dereq_("./utils").decode64;

          function SVGContainer(src) {
            this.src = src;
            this.image = null;
            var self = this;

            this.promise = this.hasFabric()
              .then(function () {
                return self.isInline(src)
                  ? Promise.resolve(self.inlineFormatting(src))
                  : XHR(src);
              })
              .then(function (svg) {
                return new Promise(function (resolve) {
                  window.html2canvas.svg.fabric.loadSVGFromString(
                    svg,
                    self.createCanvas.call(self, resolve)
                  );
                });
              });
          }

          SVGContainer.prototype.hasFabric = function () {
            return !window.html2canvas.svg || !window.html2canvas.svg.fabric
              ? Promise.reject(
                  new Error(
                    "html2canvas.svg.js is not loaded, cannot render svg"
                  )
                )
              : Promise.resolve();
          };

          SVGContainer.prototype.inlineFormatting = function (src) {
            return /^data:image\/svg\+xml;base64,/.test(src)
              ? this.decode64(this.removeContentType(src))
              : this.removeContentType(src);
          };

          SVGContainer.prototype.removeContentType = function (src) {
            return src.replace(/^data:image\/svg\+xml(;base64)?,/, "");
          };

          SVGContainer.prototype.isInline = function (src) {
            return /^data:image\/svg\+xml/i.test(src);
          };

          SVGContainer.prototype.createCanvas = function (resolve) {
            var self = this;
            return function (objects, options) {
              var canvas = new window.html2canvas.svg.fabric.StaticCanvas("c");
              self.image = canvas.lowerCanvasEl;
              canvas
                .setWidth(options.width)
                .setHeight(options.height)
                .add(
                  window.html2canvas.svg.fabric.util.groupSVGElements(
                    objects,
                    options
                  )
                )
                .renderAll();
              resolve(canvas.lowerCanvasEl);
            };
          };

          SVGContainer.prototype.decode64 = function (str) {
            return typeof window.atob === "function"
              ? window.atob(str)
              : decode64(str);
          };

          module.exports = SVGContainer;
        },
        { "./utils": 26, "./xhr": 28 },
      ],
      24: [
        function (_dereq_, module, exports) {
          var SVGContainer = _dereq_("./svgcontainer");

          function SVGNodeContainer(node, _native) {
            this.src = node;
            this.image = null;
            var self = this;

            this.promise = _native
              ? new Promise(function (resolve, reject) {
                  self.image = new Image();
                  self.image.onload = resolve;
                  self.image.onerror = reject;
                  self.image.src =
                    "data:image/svg+xml," +
                    new XMLSerializer().serializeToString(node);
                  if (self.image.complete === true) {
                    resolve(self.image);
                  }
                })
              : this.hasFabric().then(function () {
                  return new Promise(function (resolve) {
                    window.html2canvas.svg.fabric.parseSVGDocument(
                      node,
                      self.createCanvas.call(self, resolve)
                    );
                  });
                });
          }

          SVGNodeContainer.prototype = Object.create(SVGContainer.prototype);

          module.exports = SVGNodeContainer;
        },
        { "./svgcontainer": 23 },
      ],
      25: [
        function (_dereq_, module, exports) {
          var NodeContainer = _dereq_("./nodecontainer");

          function TextContainer(node, parent) {
            NodeContainer.call(this, node, parent);
          }

          TextContainer.prototype = Object.create(NodeContainer.prototype);

          TextContainer.prototype.applyTextTransform = function () {
            this.node.data = this.transform(this.parent.css("textTransform"));
          };

          TextContainer.prototype.transform = function (transform) {
            var text = this.node.data;
            switch (transform) {
              case "lowercase":
                return text.toLowerCase();
              case "capitalize":
                return text.replace(/(^|\s|:|-|\(|\))([a-z])/g, capitalize);
              case "uppercase":
                return text.toUpperCase();
              default:
                return text;
            }
          };

          function capitalize(m, p1, p2) {
            if (m.length > 0) {
              return p1 + p2.toUpperCase();
            }
          }

          module.exports = TextContainer;
        },
        { "./nodecontainer": 14 },
      ],
      26: [
        function (_dereq_, module, exports) {
          exports.smallImage = function smallImage() {
            return "";
          };

          exports.bind = function (callback, context) {
            return function () {
              return callback.apply(context, arguments);
            };
          };

          /*
           * base64-arraybuffer
           * https://github.com/niklasvh/base64-arraybuffer
           *
           * Copyright (c) 2012 Niklas von Hertzen
           * Licensed under the MIT license.
           */

          exports.decode64 = function (base64) {
            var chars =
              "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
            var len = base64.length,
              i,
              encoded1,
              encoded2,
              encoded3,
              encoded4,
              byte1,
              byte2,
              byte3;

            var output = "";

            for (i = 0; i < len; i += 4) {
              encoded1 = chars.indexOf(base64[i]);
              encoded2 = chars.indexOf(base64[i + 1]);
              encoded3 = chars.indexOf(base64[i + 2]);
              encoded4 = chars.indexOf(base64[i + 3]);

              byte1 = (encoded1 << 2) | (encoded2 >> 4);
              byte2 = ((encoded2 & 15) << 4) | (encoded3 >> 2);
              byte3 = ((encoded3 & 3) << 6) | encoded4;
              if (encoded3 === 64) {
                output += String.fromCharCode(byte1);
              } else if (encoded4 === 64 || encoded4 === -1) {
                output += String.fromCharCode(byte1, byte2);
              } else {
                output += String.fromCharCode(byte1, byte2, byte3);
              }
            }

            return output;
          };

          exports.getBounds = function (node) {
            if (node.getBoundingClientRect) {
              var clientRect = node.getBoundingClientRect();
              var width =
                node.offsetWidth == null ? clientRect.width : node.offsetWidth;
              return {
                top: clientRect.top,
                bottom: clientRect.bottom || clientRect.top + clientRect.height,
                right: clientRect.left + width,
                left: clientRect.left,
                width: width,
                height:
                  node.offsetHeight == null
                    ? clientRect.height
                    : node.offsetHeight,
              };
            }
            return {};
          };

          exports.offsetBounds = function (node) {
            var parent = node.offsetParent
              ? exports.offsetBounds(node.offsetParent)
              : { top: 0, left: 0 };

            return {
              top: node.offsetTop + parent.top,
              bottom: node.offsetTop + node.offsetHeight + parent.top,
              right: node.offsetLeft + parent.left + node.offsetWidth,
              left: node.offsetLeft + parent.left,
              width: node.offsetWidth,
              height: node.offsetHeight,
            };
          };

          exports.parseBackgrounds = function (backgroundImage) {
            var whitespace = " \r\n\t",
              method,
              definition,
              prefix,
              prefix_i,
              block,
              results = [],
              mode = 0,
              numParen = 0,
              quote,
              args;
            var appendResult = function () {
              if (method) {
                if (definition.substr(0, 1) === '"') {
                  definition = definition.substr(1, definition.length - 2);
                }
                if (definition) {
                  args.push(definition);
                }
                if (
                  method.substr(0, 1) === "-" &&
                  (prefix_i = method.indexOf("-", 1) + 1) > 0
                ) {
                  prefix = method.substr(0, prefix_i);
                  method = method.substr(prefix_i);
                }
                results.push({
                  prefix: prefix,
                  method: method.toLowerCase(),
                  value: block,
                  args: args,
                  image: null,
                });
              }
              args = [];
              method = prefix = definition = block = "";
            };
            args = [];
            method = prefix = definition = block = "";
            backgroundImage.split("").forEach(function (c) {
              if (mode === 0 && whitespace.indexOf(c) > -1) {
                return;
              }
              switch (c) {
                case '"':
                  if (!quote) {
                    quote = c;
                  } else if (quote === c) {
                    quote = null;
                  }
                  break;
                case "(":
                  if (quote) {
                    break;
                  } else if (mode === 0) {
                    mode = 1;
                    block += c;
                    return;
                  } else {
                    numParen++;
                  }
                  break;
                case ")":
                  if (quote) {
                    break;
                  } else if (mode === 1) {
                    if (numParen === 0) {
                      mode = 0;
                      block += c;
                      appendResult();
                      return;
                    } else {
                      numParen--;
                    }
                  }
                  break;

                case ",":
                  if (quote) {
                    break;
                  } else if (mode === 0) {
                    appendResult();
                    return;
                  } else if (mode === 1) {
                    if (numParen === 0 && !method.match(/^url$/i)) {
                      args.push(definition);
                      definition = "";
                      block += c;
                      return;
                    }
                  }
                  break;
              }

              block += c;
              if (mode === 0) {
                method += c;
              } else {
                definition += c;
              }
            });

            appendResult();
            return results;
          };
        },
        {},
      ],
      27: [
        function (_dereq_, module, exports) {
          var GradientContainer = _dereq_("./gradientcontainer");

          function WebkitGradientContainer(imageData) {
            GradientContainer.apply(this, arguments);
            this.type =
              imageData.args[0] === "linear"
                ? GradientContainer.TYPES.LINEAR
                : GradientContainer.TYPES.RADIAL;
          }

          WebkitGradientContainer.prototype = Object.create(
            GradientContainer.prototype
          );

          module.exports = WebkitGradientContainer;
        },
        { "./gradientcontainer": 9 },
      ],
      28: [
        function (_dereq_, module, exports) {
          function XHR(url) {
            return new Promise(function (resolve, reject) {
              var xhr = new XMLHttpRequest();
              xhr.open("GET", url);

              xhr.onload = function () {
                if (xhr.status === 200) {
                  resolve(xhr.responseText);
                } else {
                  reject(new Error(xhr.statusText));
                }
              };

              xhr.onerror = function () {
                reject(new Error("Network Error"));
              };

              xhr.send();
            });
          }

          module.exports = XHR;
        },
        {},
      ],
    },
    {},
    [4]
  )(4);
});
